From 5d9586c9cdc34d5dece6229f800a716f58975934 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Sun, 3 Dec 2023 22:12:31 -0600 Subject: [PATCH 01/23] Start Decompiling hsfload.c --- config/GMPE01_00/symbols.txt | 3 +- configure.py | 2 +- include/game/hsfformat.h | 249 +++++++++++++++++++++++++++++++++++ src/game/hsfload.c | 247 ++++++++++++++++++++++++++++++++++ 4 files changed, 499 insertions(+), 2 deletions(-) create mode 100644 include/game/hsfformat.h create mode 100644 src/game/hsfload.c diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index 3e4df24f..f0fb8689 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -5399,7 +5399,8 @@ HuSprOrder = .bss:0x8015AE90; // type:object size:0x1800 bmpNoCC = .bss:0x8015C690; // type:object size:0x20 scope:local HuSprLayerDrawNo = .bss:0x8015C6B0; // type:object size:0x10 scope:local Model = .bss:0x8015C6C0; // type:object size:0x80 -head = .bss:0x8015C740; // type:object size:0x240 +head = .bss:0x8015C740; // type:object size:0xB0 +rgba = .bss:0x8015C7F0; // type:object size:0x190 lbl_8015C980 = .bss:0x8015C980; // type:object size:0x300 scope:local data:byte DrawObjData = .bss:0x8015CC80; // type:object size:0x9000 scope:local BmpPtrBak = .bss:0x80165C80; // type:object size:0x20 scope:local data:4byte diff --git a/configure.py b/configure.py index 8c02fecf..8c1b85db 100755 --- a/configure.py +++ b/configure.py @@ -245,7 +245,7 @@ config.libs = [ Object(Matching, "game/process.c"), Object(Matching, "game/sprman.c"), Object(Matching, "game/sprput.c"), - Object(NonMatching, "game/hsfload.c"), + Object(Matching, "game/hsfload.c"), Object(NonMatching, "game/hsfdraw.c"), Object(NonMatching, "game/hsfman.c"), Object(NonMatching, "game/hsfmotion.c"), diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h new file mode 100644 index 00000000..875b6725 --- /dev/null +++ b/include/game/hsfformat.h @@ -0,0 +1,249 @@ +#ifndef _HSF_FORMAT_H +#define _HSF_FORMAT_H + +#include "dolphin.h" + +typedef struct hsf_section { + s32 ofs; + s32 count; +} HsfSection; + +typedef struct hsf_header { + char magic[8]; + HsfSection scene; + HsfSection color; + HsfSection material; + HsfSection attribute; + HsfSection vertex; + HsfSection normal; + HsfSection st; + HsfSection face; + HsfSection object; + HsfSection bitmap; + HsfSection palette; + HsfSection motion; + HsfSection cenv; + HsfSection skeleton; + HsfSection part; + HsfSection cluster; + HsfSection shape; + HsfSection mapAttr; + HsfSection matrix; + HsfSection symbol; + HsfSection string; +} HsfHeader; + +typedef struct hsf_scene { + GXColor unk0; + f32 unk4; + f32 unk8; + u32 unkC; +} HsfScene; + +typedef struct hsf_bitmap { + char *name; + s32 maxLod; + u8 dataFmt; + u8 pixSize; + u16 w; + u16 h; + u16 palSize; + GXColor tint; + void *palData; + u32 unk; + void *data; +} HsfBitmap; + +typedef struct hsf_palette { + char *name; + int unk; + int palSize; + void *data; +} HsfPalette; + +typedef struct hsf_attribute { + char *name; + u8 unk[124]; + HsfBitmap *bitmap; +} HsfAttribute; + +typedef struct hsf_material { + char *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; + HsfAttribute **attrs; +} HsfMaterial; + +typedef struct hsf_vertex_buf { + char *name; + u32 count; + void *data; +} HsfVertexBuf; + +typedef struct hsf_face { + u16 type; + u16 mat; + u16 indices[12]; + union { + struct { + u32 count; + u16 *data; + } strip; + u16 ext_indices[4]; + }; +} HSFFace; + +typedef struct hsf_face_buf { + char *name; + u32 count; + HSFFace *data; +} HsfFaceBuf; + +typedef struct hsf_const_data { + u32 flags; + u8 unk[64]; +} HsfConstData; + +typedef struct hsf_transform { + Vec pos; + Vec rot; + Vec scale; +} HsfTransform; + +typedef struct hsf_object { + char *name; + u32 type; + HsfConstData *constData; + u32 flags; + u32 idx; + u32 childrenCount; + struct hsf_object **children; + HsfTransform base; + HsfTransform curr; + Vec min; + Vec max; + u8 unk[136]; + HsfFaceBuf *face; + HsfVertexBuf *vertex; + HsfVertexBuf *normal; + HsfVertexBuf *st; + HsfVertexBuf *color; + HsfMaterial *material; + HsfAttribute *attribute; + u8 unk2[36]; +} HsfObject; + +typedef struct hsf_cenv { + u8 unk[36]; +} HsfCenv; + +typedef struct hsf_part { + char *name; + u32 count; + u16 *data; +} HsfPart; + +typedef struct hsf_cluster { + char *name[3]; + HsfPart *part; + u8 unk[144]; +} HsfCluster; + +typedef struct hsf_shape { + char *name; + u16 count1; + u16 morphTargetCnt; + HsfVertexBuf **morphTargets; +} HsfShape; + +typedef struct hsf_skeleton { + char *name; + HsfTransform transform; +} HsfSkeleton; + +typedef struct hsf_track { + u8 mode; + u8 value; + s16 idx; + s16 type; + s16 effect; + s16 curveType; + s16 numKeyframes; + void *data; +} HsfTrack; + +typedef struct hsf_motion { + char *name; + u32 numTracks; + HsfTrack *track; + float len; +} HsfMotion; + +typedef struct hsf_map_attr { + u8 unk[16]; + void *unk10; + u8 unk2[4]; +} HsfMapAttr; + +typedef struct hsf_matrix { + u32 base_idx; + u32 count; + Mtx *data; +} HsfMatrix; + +typedef struct hsf_data { + u8 magic[8]; + HsfScene *scene; + HsfAttribute *attribute; + HsfMaterial *material; + HsfVertexBuf *vertex; + HsfVertexBuf *normal; + HsfVertexBuf *st; + HsfVertexBuf *color; + HsfFaceBuf *face; + HsfBitmap *bitmap; + HsfPalette *palette; + HsfObject *root; + HsfCenv *cenv; + HsfSkeleton *skeleton; + HsfCluster *cluster; + HsfPart *part; + HsfShape *shape; + HsfMotion *motion; + HsfObject *object; + HsfMapAttr *mapAttr; + HsfMatrix *matrix; + s16 sceneCnt; + s16 attributeCnt; + s16 materialCnt; + s16 vertexCnt; + s16 normalCnt; + s16 stCnt; + s16 colorCnt; + s16 faceCnt; + s16 bitmapCnt; + s16 paletteCnt; + s16 objectCnt; + s16 cenvCnt; + s16 skeletonCnt; + s16 clusterCnt; + s16 partCnt; + s16 shapeCnt; + s16 mapAttrCnt; + s16 motionCnt; + s16 matrixCnt; +} HsfData; + +#endif \ No newline at end of file diff --git a/src/game/hsfload.c b/src/game/hsfload.c new file mode 100644 index 00000000..26ce0d2a --- /dev/null +++ b/src/game/hsfload.c @@ -0,0 +1,247 @@ +#include "game/hsfformat.h" + +GXColor rgba[400]; +HsfHeader head; +HsfData Model; + +static BOOL MotionOnly; +static HsfData *MotionModel; +static HsfVertexBuf *VertexDataTop; +static HsfVertexBuf *NormalDataTop; +void *fileptr; +char *StringTable; +char *DicStringTable; +void **NSymIndex; +HsfObject *objtop; +HsfVertexBuf *vtxtop; +HsfCluster *ClusterTop; +HsfAttribute *AttributeTop; +HsfMaterial *MaterialTop; + +static void FileLoad(void *data); +static HsfData *SetHsfModel(void); +static void MaterialLoad(void); +static void AttributeLoad(void); +static void SceneLoad(void); +static void ColorLoad(void); +static void VertexLoad(void); +static void NormalLoad(void); +static void STLoad(void); +static void FaceLoad(void); +static void ObjectLoad(void); +static void CenvLoad(void); +static void SkeletonLoad(void); +static void PartLoad(void); +static void ClusterLoad(void); +static void ShapeLoad(void); +static void MapAttrLoad(void); +static void PaletteLoad(void); +static void BitmapLoad(void); +static void MotionLoad(void); +static void MatrixLoad(void); + +static HsfBitmap *SearchBitmapPtr(s32 id); +static char *GetString(u32 *str_ofs); + +HsfData *LoadHSF(void *data) +{ + HsfData *hsf; + Model.root = NULL; + objtop = NULL; + FileLoad(data); + SceneLoad(); + ColorLoad(); + PaletteLoad(); + BitmapLoad(); + MaterialLoad(); + AttributeLoad(); + VertexLoad(); + NormalLoad(); + STLoad(); + FaceLoad(); + ObjectLoad(); + CenvLoad(); + SkeletonLoad(); + PartLoad(); + ClusterLoad(); + ShapeLoad(); + MapAttrLoad(); + MotionLoad(); + MatrixLoad(); + hsf = SetHsfModel(); + InitEnvelope(hsf); + objtop = NULL; + return hsf; + +} + +static void FileLoad(void *data) +{ + fileptr = data; + memcpy(&head, fileptr, sizeof(HsfHeader)); + memset(&Model, 0, sizeof(HsfData)); + NSymIndex = (void **)((u32)fileptr+head.symbol.ofs); + StringTable = (char *)((u32)fileptr+head.string.ofs); + ClusterTop = (HsfCluster *)((u32)fileptr+head.cluster.ofs); + AttributeTop = (HsfAttribute *)((u32)fileptr+head.attribute.ofs); + MaterialTop = (HsfMaterial *)((u32)fileptr+head.material.ofs); +} + +static HsfData *SetHsfModel(void) +{ + HsfData *data = fileptr; + data->scene = Model.scene; + data->sceneCnt = Model.sceneCnt; + data->attribute = Model.attribute; + data->attributeCnt = Model.attributeCnt; + data->bitmap = Model.bitmap; + data->bitmapCnt = Model.bitmapCnt; + data->cenv = Model.cenv; + data->cenvCnt = Model.cenvCnt; + data->skeleton = Model.skeleton; + data->skeletonCnt = Model.skeletonCnt; + data->face = Model.face; + data->faceCnt = Model.faceCnt; + data->material = Model.material; + data->materialCnt = Model.materialCnt; + data->motion = Model.motion; + data->motionCnt = Model.motionCnt; + data->normal = Model.normal; + data->normalCnt = Model.normalCnt; + data->root = Model.root; + data->objectCnt = Model.objectCnt; + data->object = objtop; + data->matrix = Model.matrix; + data->matrixCnt = Model.matrixCnt; + data->palette = Model.palette; + data->paletteCnt = Model.paletteCnt; + data->st = Model.st; + data->stCnt = Model.stCnt; + data->vertex = Model.vertex; + data->vertexCnt = Model.vertexCnt; + data->cenv = Model.cenv; + data->cenvCnt = Model.cenvCnt; + data->cluster = Model.cluster; + data->clusterCnt = Model.clusterCnt; + data->part = Model.part; + data->partCnt = Model.partCnt; + data->shape = Model.shape; + data->shapeCnt = Model.shapeCnt; + data->mapAttr = Model.mapAttr; + data->mapAttrCnt = Model.mapAttrCnt; + return data; +} + +char *SetName(u32 *str_ofs) +{ + char *ret = GetString(str_ofs); + return ret; +} + +static void MaterialLoad(void) +{ + s32 i; + s32 j; + if(head.material.count) { + HsfMaterial *file_mat = (HsfMaterial *)((u32)fileptr+head.material.ofs); + HsfMaterial *curr_mat; + HsfMaterial *new_mat; + for(i=0; iname = SetName((u32 *)&curr_mat->name); + new_mat->pass = curr_mat->pass; + new_mat->vtxMode = curr_mat->vtxMode; + new_mat->litColor[0] = curr_mat->litColor[0]; + new_mat->litColor[1] = curr_mat->litColor[1]; + new_mat->litColor[2] = curr_mat->litColor[2]; + new_mat->color[0] = curr_mat->color[0]; + new_mat->color[1] = curr_mat->color[1]; + new_mat->color[2] = curr_mat->color[2]; + new_mat->shadowColor[0] = curr_mat->shadowColor[0]; + new_mat->shadowColor[1] = curr_mat->shadowColor[1]; + new_mat->shadowColor[2] = curr_mat->shadowColor[2]; + new_mat->hilite_scale = curr_mat->hilite_scale; + new_mat->unk18 = curr_mat->unk18; + new_mat->invAlpha = curr_mat->invAlpha; + new_mat->unk20[0] = curr_mat->unk20[0]; + new_mat->unk20[1] = curr_mat->unk20[1]; + new_mat->refAlpha = curr_mat->refAlpha; + new_mat->unk2C = curr_mat->unk2C; + new_mat->numAttrs = curr_mat->numAttrs; + new_mat->attrs = (HsfAttribute **)(NSymIndex+((u32)curr_mat->attrs)); + rgba[i].r = new_mat->litColor[0]; + rgba[i].g = new_mat->litColor[1]; + rgba[i].b = new_mat->litColor[2]; + rgba[i].a = 255; + for(j=0; jnumAttrs; j++) { + new_mat->attrs[j] = new_mat->attrs[j]; + } + } + } +} + +static void AttributeLoad(void) +{ + HsfAttribute *file_attr; + HsfAttribute *new_attr; + HsfAttribute *temp_attr; + s32 i; + if(head.attribute.count) { + temp_attr = file_attr = (HsfAttribute *)((u32)fileptr+head.attribute.ofs); + new_attr = temp_attr; + Model.attribute = new_attr; + Model.attributeCnt = head.attribute.count; + for(i=0; iname = SetName((u32 *)&file_attr[i].name); + } else { + new_attr->name = NULL; + } + new_attr->bitmap = SearchBitmapPtr((s32)file_attr[i].bitmap); + } + } +} + +static void SceneLoad(void) +{ + HsfScene *file_scene; + HsfScene *new_scene; + if(head.scene.count) { + file_scene = (HsfScene *)((u32)fileptr+head.scene.ofs); + new_scene = file_scene; + new_scene->unk8 = file_scene->unk8; + new_scene->unk4 = file_scene->unk4; + Model.scene = new_scene; + Model.sceneCnt = head.scene.count; + } +} + +static HsfBitmap *SearchBitmapPtr(s32 id) +{ + HsfBitmap *bitmap; + if(id == -1) { + return NULL; + } + bitmap = (HsfBitmap *)((u32)fileptr+head.bitmap.ofs); + bitmap += id; + return bitmap; +} + +static char *GetString(u32 *str_ofs) +{ + char *ret = &StringTable[*str_ofs]; + return ret; +} + +static char *GetMotionString(u16 *str_ofs) +{ + char *ret = &StringTable[*str_ofs]; + return ret; +} \ No newline at end of file From 2f01f964c6f84e2376d7bad9ea3c5f53d10333bb Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Sun, 3 Dec 2023 22:19:54 -0600 Subject: [PATCH 02/23] Fix types of VertexDataTop and NormalDataTop --- src/game/hsfload.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 26ce0d2a..83f413d3 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -6,8 +6,8 @@ HsfData Model; static BOOL MotionOnly; static HsfData *MotionModel; -static HsfVertexBuf *VertexDataTop; -static HsfVertexBuf *NormalDataTop; +static void *VertexDataTop; +static void *NormalDataTop; void *fileptr; char *StringTable; char *DicStringTable; From b075c8700af82afd19516c34e94ebf90cd968a11 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Sun, 3 Dec 2023 22:33:28 -0600 Subject: [PATCH 03/23] Fix rgba size --- src/game/hsfload.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 83f413d3..ca62b794 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1,6 +1,6 @@ #include "game/hsfformat.h" -GXColor rgba[400]; +GXColor rgba[100]; HsfHeader head; HsfData Model; From 28e2b1db197c2a238d49f0ed8e19eabf75daee6d Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Sun, 3 Dec 2023 23:21:51 -0600 Subject: [PATCH 04/23] Match ColorLoad --- src/game/hsfload.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index ca62b794..e6f69db1 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -223,6 +223,33 @@ static void SceneLoad(void) } } + +static void ColorLoad(void) +{ + s32 i; + HsfVertexBuf *file_color; + HsfVertexBuf *new_color; + void *data; + void *color_data; + HsfVertexBuf *temp_color; + + if(head.color.count) { + temp_color = file_color = (HsfVertexBuf *)((u32)fileptr+head.color.ofs); + data = &file_color[head.color.count]; + for(i=0; idata; + new_color->name = SetName((u32 *)&file_color->name); + new_color->data = (void *)((u32)data+(u32)color_data); + } + } +} + static HsfBitmap *SearchBitmapPtr(s32 id) { HsfBitmap *bitmap; From 089bd06175994446f3f7bc50f130ed62823599d7 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 07:53:53 -0600 Subject: [PATCH 05/23] Decompile Vertex Loading Functions --- include/game/hsfformat.h | 39 ++++++++------ src/game/hsfload.c | 108 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 131 insertions(+), 16 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 875b6725..fa43d0ae 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -3,6 +3,17 @@ #include "dolphin.h" +typedef struct hsf_vector3f { + float x; + float y; + float z; +} HsfVector3f; + +typedef struct hsf_vector2f { + float x; + float y; +} HsfVector2f; + typedef struct hsf_section { s32 ofs; s32 count; @@ -88,7 +99,7 @@ typedef struct hsf_material { typedef struct hsf_vertex_buf { char *name; - u32 count; + s32 count; void *data; } HsfVertexBuf; @@ -105,12 +116,6 @@ typedef struct hsf_face { }; } HSFFace; -typedef struct hsf_face_buf { - char *name; - u32 count; - HSFFace *data; -} HsfFaceBuf; - typedef struct hsf_const_data { u32 flags; u8 unk[64]; @@ -122,12 +127,8 @@ typedef struct hsf_transform { Vec scale; } HsfTransform; -typedef struct hsf_object { - char *name; - u32 type; - HsfConstData *constData; - u32 flags; - u32 idx; +typedef struct hsf_object_data { + struct hsf_object *parent; u32 childrenCount; struct hsf_object **children; HsfTransform base; @@ -135,7 +136,7 @@ typedef struct hsf_object { Vec min; Vec max; u8 unk[136]; - HsfFaceBuf *face; + HsfVertexBuf *face; HsfVertexBuf *vertex; HsfVertexBuf *normal; HsfVertexBuf *st; @@ -143,6 +144,14 @@ typedef struct hsf_object { HsfMaterial *material; HsfAttribute *attribute; u8 unk2[36]; +} HsfObjectData; + +typedef struct hsf_object { + char *name; + u32 type; + HsfConstData *constData; + u32 flags; + HsfObjectData data; } HsfObject; typedef struct hsf_cenv { @@ -212,7 +221,7 @@ typedef struct hsf_data { HsfVertexBuf *normal; HsfVertexBuf *st; HsfVertexBuf *color; - HsfFaceBuf *face; + HsfVertexBuf *face; HsfBitmap *bitmap; HsfPalette *palette; HsfObject *root; diff --git a/src/game/hsfload.c b/src/game/hsfload.c index e6f69db1..8ce0c687 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -223,7 +223,6 @@ static void SceneLoad(void) } } - static void ColorLoad(void) { s32 i; @@ -250,6 +249,113 @@ static void ColorLoad(void) } } +static void VertexLoad(void) +{ + s32 i, j; + HsfVertexBuf *file_vertex; + HsfVertexBuf *new_vertex; + void *data; + HsfVector3f *data_elem; + void *temp_data; + + if(head.vertex.count) { + vtxtop = file_vertex = (HsfVertexBuf *)((u32)fileptr+head.vertex.ofs); + data = (void *)&file_vertex[head.vertex.count]; + for(i=0; icount; j++) { + data_elem = (HsfVector3f *)(((u32)data)+((u32)file_vertex->data)+(j*sizeof(HsfVector3f))); + } + } + new_vertex = vtxtop; + Model.vertex = new_vertex; + Model.vertexCnt = head.vertex.count; + file_vertex = (HsfVertexBuf *)((u32)fileptr+head.vertex.ofs); + VertexDataTop = data = (void *)&file_vertex[head.vertex.count]; + for(i=0; idata; + new_vertex->count = file_vertex->count; + new_vertex->name = SetName((u32 *)&file_vertex->name); + new_vertex->data = (void *)((u32)data+(u32)temp_data); + for(j=0; jcount; j++) { + data_elem = (HsfVector3f *)(((u32)data)+((u32)temp_data)+(j*sizeof(HsfVector3f))); + ((HsfVector3f *)new_vertex->data)[j].x = data_elem->x; + ((HsfVector3f *)new_vertex->data)[j].y = data_elem->y; + ((HsfVector3f *)new_vertex->data)[j].z = data_elem->z; + } + } + } +} + +static void NormalLoad(void) +{ + s32 i, j; + void *temp_data; + HsfVertexBuf *file_normal; + HsfVertexBuf *new_normal; + HsfVertexBuf *temp_normal; + void *data; + + + if(head.normal.count) { + s32 cenv_count = head.cenv.count; + temp_normal = file_normal = (HsfVertexBuf *)((u32)fileptr+head.normal.ofs); + data = (void *)&file_normal[head.normal.count]; + new_normal = temp_normal; + Model.normal = new_normal; + Model.normalCnt = head.normal.count; + file_normal = (HsfVertexBuf *)((u32)fileptr+head.normal.ofs); + NormalDataTop = data = (void *)&file_normal[head.normal.count]; + for(i=0; idata; + new_normal->count = file_normal->count; + new_normal->name = SetName((u32 *)&file_normal->name); + new_normal->data = (void *)((u32)data+(u32)temp_data); + } + } +} + +static void STLoad(void) +{ + s32 i, j; + HsfVertexBuf *file_st; + HsfVertexBuf *temp_st; + HsfVertexBuf *new_st; + void *data; + HsfVector2f *data_elem; + void *temp_data; + + if(head.st.count) { + temp_st = file_st = (HsfVertexBuf *)((u32)fileptr+head.st.ofs); + data = (void *)&file_st[head.st.count]; + for(i=0; icount; j++) { + data_elem = (HsfVector2f *)(((u32)data)+((u32)file_st->data)+(j*sizeof(HsfVector2f))); + } + } + new_st = temp_st; + Model.st = new_st; + Model.stCnt = head.st.count; + file_st = (HsfVertexBuf *)((u32)fileptr+head.st.ofs); + data = (void *)&file_st[head.st.count]; + for(i=0; idata; + new_st->count = file_st->count; + new_st->name = SetName((u32 *)&file_st->name); + new_st->data = (void *)((u32)data+(u32)temp_data); + for(j=0; jcount; j++) { + data_elem = (HsfVector2f *)(((u32)data)+((u32)temp_data)+(j*sizeof(HsfVector2f))); + ((HsfVector2f *)new_st->data)[j].x = data_elem->x; + ((HsfVector2f *)new_st->data)[j].y = data_elem->y; + } + } + } +} + +static void FaceLoad(void) +{ + +} + static HsfBitmap *SearchBitmapPtr(s32 id) { HsfBitmap *bitmap; From afac7f1f7bebf84b865b32b1f3a3c7803b9bf566 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 08:30:18 -0600 Subject: [PATCH 06/23] Match FaceLoad --- include/game/hsfformat.h | 90 +++++++++++++++++++++++----------------- src/game/hsfload.c | 75 ++++++++++++++++++++++++--------- 2 files changed, 106 insertions(+), 59 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index fa43d0ae..24ae8d33 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -101,7 +101,11 @@ typedef struct hsf_vertex_buf { char *name; s32 count; void *data; -} HsfVertexBuf; +} HsfBuffer; + +typedef struct hsf_tristrip { + u16 data[4]; +} HsfTristrip; typedef struct hsf_face { u16 type; @@ -110,11 +114,12 @@ typedef struct hsf_face { union { struct { u32 count; - u16 *data; + HsfTristrip *data; } strip; u16 ext_indices[4]; }; -} HSFFace; + float nbt[3]; +} HsfFace; typedef struct hsf_const_data { u32 flags; @@ -122,38 +127,11 @@ typedef struct hsf_const_data { } HsfConstData; typedef struct hsf_transform { - Vec pos; - Vec rot; - Vec scale; + HsfVector3f pos; + HsfVector3f rot; + HsfVector3f scale; } HsfTransform; -typedef struct hsf_object_data { - struct hsf_object *parent; - u32 childrenCount; - struct hsf_object **children; - HsfTransform base; - HsfTransform curr; - Vec min; - Vec max; - u8 unk[136]; - HsfVertexBuf *face; - HsfVertexBuf *vertex; - HsfVertexBuf *normal; - HsfVertexBuf *st; - HsfVertexBuf *color; - HsfMaterial *material; - HsfAttribute *attribute; - u8 unk2[36]; -} HsfObjectData; - -typedef struct hsf_object { - char *name; - u32 type; - HsfConstData *constData; - u32 flags; - HsfObjectData data; -} HsfObject; - typedef struct hsf_cenv { u8 unk[36]; } HsfCenv; @@ -174,9 +152,43 @@ typedef struct hsf_shape { char *name; u16 count1; u16 morphTargetCnt; - HsfVertexBuf **morphTargets; + HsfBuffer **morphTargets; } HsfShape; +typedef struct hsf_object_data { + struct hsf_object *parent; + u32 childrenCount; + struct hsf_object **children; + HsfTransform base; + HsfTransform curr; + Vec min; + Vec max; + u8 unk[136]; + HsfBuffer *face; + HsfBuffer *vertex; + HsfBuffer *normal; + HsfBuffer *st; + HsfBuffer *color; + HsfMaterial *material; + HsfAttribute *attribute; + u8 unk2[12]; + u32 vertexShapeCnt; + HsfBuffer **vertexShape; + u32 clusterCnt; + HsfCluster **cluster; + u32 hook; + HsfCenv *cenv; + void *file[2]; +} HsfObjectData; + +typedef struct hsf_object { + char *name; + u32 type; + HsfConstData *constData; + u32 flags; + HsfObjectData data; +} HsfObject; + typedef struct hsf_skeleton { char *name; HsfTransform transform; @@ -217,11 +229,11 @@ typedef struct hsf_data { HsfScene *scene; HsfAttribute *attribute; HsfMaterial *material; - HsfVertexBuf *vertex; - HsfVertexBuf *normal; - HsfVertexBuf *st; - HsfVertexBuf *color; - HsfVertexBuf *face; + HsfBuffer *vertex; + HsfBuffer *normal; + HsfBuffer *st; + HsfBuffer *color; + HsfBuffer *face; HsfBitmap *bitmap; HsfPalette *palette; HsfObject *root; diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 8ce0c687..14a77e05 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -13,7 +13,7 @@ char *StringTable; char *DicStringTable; void **NSymIndex; HsfObject *objtop; -HsfVertexBuf *vtxtop; +HsfBuffer *vtxtop; HsfCluster *ClusterTop; HsfAttribute *AttributeTop; HsfMaterial *MaterialTop; @@ -226,20 +226,20 @@ static void SceneLoad(void) static void ColorLoad(void) { s32 i; - HsfVertexBuf *file_color; - HsfVertexBuf *new_color; + HsfBuffer *file_color; + HsfBuffer *new_color; void *data; void *color_data; - HsfVertexBuf *temp_color; + HsfBuffer *temp_color; if(head.color.count) { - temp_color = file_color = (HsfVertexBuf *)((u32)fileptr+head.color.ofs); + temp_color = file_color = (HsfBuffer *)((u32)fileptr+head.color.ofs); data = &file_color[head.color.count]; for(i=0; idata; @@ -252,14 +252,14 @@ static void ColorLoad(void) static void VertexLoad(void) { s32 i, j; - HsfVertexBuf *file_vertex; - HsfVertexBuf *new_vertex; + HsfBuffer *file_vertex; + HsfBuffer *new_vertex; void *data; HsfVector3f *data_elem; void *temp_data; if(head.vertex.count) { - vtxtop = file_vertex = (HsfVertexBuf *)((u32)fileptr+head.vertex.ofs); + vtxtop = file_vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs); data = (void *)&file_vertex[head.vertex.count]; for(i=0; icount; j++) { @@ -269,7 +269,7 @@ static void VertexLoad(void) new_vertex = vtxtop; Model.vertex = new_vertex; Model.vertexCnt = head.vertex.count; - file_vertex = (HsfVertexBuf *)((u32)fileptr+head.vertex.ofs); + file_vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs); VertexDataTop = data = (void *)&file_vertex[head.vertex.count]; for(i=0; idata; @@ -290,20 +290,20 @@ static void NormalLoad(void) { s32 i, j; void *temp_data; - HsfVertexBuf *file_normal; - HsfVertexBuf *new_normal; - HsfVertexBuf *temp_normal; + HsfBuffer *file_normal; + HsfBuffer *new_normal; + HsfBuffer *temp_normal; void *data; if(head.normal.count) { s32 cenv_count = head.cenv.count; - temp_normal = file_normal = (HsfVertexBuf *)((u32)fileptr+head.normal.ofs); + temp_normal = file_normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs); data = (void *)&file_normal[head.normal.count]; new_normal = temp_normal; Model.normal = new_normal; Model.normalCnt = head.normal.count; - file_normal = (HsfVertexBuf *)((u32)fileptr+head.normal.ofs); + file_normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs); NormalDataTop = data = (void *)&file_normal[head.normal.count]; for(i=0; idata; @@ -317,15 +317,15 @@ static void NormalLoad(void) static void STLoad(void) { s32 i, j; - HsfVertexBuf *file_st; - HsfVertexBuf *temp_st; - HsfVertexBuf *new_st; + HsfBuffer *file_st; + HsfBuffer *temp_st; + HsfBuffer *new_st; void *data; HsfVector2f *data_elem; void *temp_data; if(head.st.count) { - temp_st = file_st = (HsfVertexBuf *)((u32)fileptr+head.st.ofs); + temp_st = file_st = (HsfBuffer *)((u32)fileptr+head.st.ofs); data = (void *)&file_st[head.st.count]; for(i=0; icount; j++) { @@ -335,7 +335,7 @@ static void STLoad(void) new_st = temp_st; Model.st = new_st; Model.stCnt = head.st.count; - file_st = (HsfVertexBuf *)((u32)fileptr+head.st.ofs); + file_st = (HsfBuffer *)((u32)fileptr+head.st.ofs); data = (void *)&file_st[head.st.count]; for(i=0; idata; @@ -353,7 +353,42 @@ static void STLoad(void) static void FaceLoad(void) { + HsfBuffer *file_face; + HsfBuffer *new_face; + HsfBuffer *temp_face; + HsfFace *temp_data; + HsfFace *data; + HsfFace *file_face_strip; + HsfFace *new_face_strip; + HsfTristrip *strip; + s32 i; + s32 j; + if(head.face.count) { + temp_face = file_face = (HsfBuffer *)((u32)fileptr+head.face.ofs); + data = (HsfFace *)&file_face[head.face.count]; + new_face = temp_face; + Model.face = new_face; + Model.faceCnt = head.face.count; + file_face = (HsfBuffer *)((u32)fileptr+head.face.ofs); + data = (HsfFace *)&file_face[head.face.count]; + for(i=0; idata; + new_face->name = SetName((u32 *)&file_face->name); + new_face->count = file_face->count; + new_face->data = (void *)((u32)data+(u32)temp_data); + strip = (HsfTristrip *)(&((HsfFace *)new_face->data)[new_face->count]); + } + new_face = temp_face; + for(i=0; idata; + for(j=0; jcount; j++, new_face_strip++, file_face_strip++) { + if(file_face_strip->type == 4) { + new_face_strip->strip.data = &strip[(s32)file_face_strip->strip.data]; + } + } + } + } } static HsfBitmap *SearchBitmapPtr(s32 id) From 1574109c8e0e817a49bcbba562d8972fa215c663 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 10:23:10 -0600 Subject: [PATCH 07/23] Nearly match DispObject temp_parent and temp_cluster are swapped in stack allocation order --- include/game/hsfformat.h | 20 ++- include/string.h | 18 +++ src/game/hsfload.c | 333 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 363 insertions(+), 8 deletions(-) create mode 100644 include/string.h diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 24ae8d33..a8a0fb33 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -67,8 +67,8 @@ typedef struct hsf_bitmap { typedef struct hsf_palette { char *name; - int unk; - int palSize; + s32 unk; + s32 palSize; void *data; } HsfPalette; @@ -161,17 +161,23 @@ typedef struct hsf_object_data { struct hsf_object **children; HsfTransform base; HsfTransform curr; - Vec min; - Vec max; - u8 unk[136]; + union { + struct { + HsfVector3f min; + HsfVector3f max; + u8 unk[136]; + } mesh; + struct hsf_object *unk64; + }; + HsfBuffer *face; HsfBuffer *vertex; HsfBuffer *normal; - HsfBuffer *st; HsfBuffer *color; + HsfBuffer *st; HsfMaterial *material; HsfAttribute *attribute; - u8 unk2[12]; + u8 unk2[4]; u32 vertexShapeCnt; HsfBuffer **vertexShape; u32 clusterCnt; diff --git a/include/string.h b/include/string.h new file mode 100644 index 00000000..583a906d --- /dev/null +++ b/include/string.h @@ -0,0 +1,18 @@ +#ifndef _STRING_H_ +#define _STRING_H_ + +typedef unsigned long size_t; + +void* memcpy(void* dst, const void* src, size_t n); +void* memset(void* dst, int val, size_t n); + +char* strrchr(const char* str, int c); +char* strchr(const char* str, int c); +int strncmp(const char* str1, const char* str2, size_t n); +int strcmp(const char* str1, const char* str2); +char* strcat(char* dst, const char* src); +char* strncpy(char* dst, const char* src, size_t n); +char* strcpy(char* dst, const char* src); +size_t strlen(const char* str); + +#endif \ No newline at end of file diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 14a77e05..93df141f 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1,4 +1,5 @@ #include "game/hsfformat.h" +#include "string.h" GXColor rgba[100]; HsfHeader head; @@ -40,6 +41,15 @@ static void BitmapLoad(void); static void MotionLoad(void); static void MatrixLoad(void); +static HsfBuffer *SearchVertexPtr(s32 id); +static HsfBuffer *SearchNormalPtr(s32 id); +static HsfBuffer *SearchStPtr(s32 id); +static HsfBuffer *SearchColorPtr(s32 id); +static HsfBuffer *SearchFacePtr(s32 id); +static HsfCenv *SearchCenvPtr(s32 id); +static HsfPart *SearchPartPtr(s32 id); +static HsfPalette *SearchPalettePtr(s32 id); + static HsfBitmap *SearchBitmapPtr(s32 id); static char *GetString(u32 *str_ofs); @@ -384,13 +394,334 @@ static void FaceLoad(void) file_face_strip = new_face_strip = new_face->data; for(j=0; jcount; j++, new_face_strip++, file_face_strip++) { if(file_face_strip->type == 4) { - new_face_strip->strip.data = &strip[(s32)file_face_strip->strip.data]; + new_face_strip->strip.data = &strip[(u32)file_face_strip->strip.data]; } } } } } +static void DispObject(HsfObject *parent, HsfObject *object) +{ + + u32 i; + HsfObject *child_obj; + + HsfObject *temp_object; + + HsfCluster *temp_cluster; + HsfObject *temp_parent = parent; + HsfBuffer *shape; + + + object->type = object->type; + switch(object->type) { + case 2: + { + HsfObjectData *data; + HsfObject *new_object; + + data = &object->data; + new_object = temp_object = object; + new_object->data.childrenCount = data->childrenCount; + new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + new_object->data.parent = parent; + if(Model.root == NULL) { + Model.root = temp_object; + } + new_object->type = 2; + new_object->data.vertex = SearchVertexPtr((s32)data->vertex); + new_object->data.normal = SearchNormalPtr((s32)data->normal); + 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]; + for(i=0; idata.vertexShapeCnt; i++) { + HsfBuffer *shape = &vtxtop[(u32)new_object->data.vertexShape[i]]; + new_object->data.vertexShape[i] = shape; + } + new_object->data.cluster = (HsfCluster **)&NSymIndex[(u32)data->cluster]; + for(i=0; idata.clusterCnt; i++) { + temp_cluster = &ClusterTop[(u32)new_object->data.cluster[i]]; + new_object->data.cluster[i] = temp_cluster; + } + new_object->data.cenv = SearchCenvPtr((s32)data->cenv); + new_object->data.material = Model.material; + if((s32)data->attribute >= 0) { + new_object->data.attribute = Model.attribute; + } else { + new_object->data.attribute = NULL; + } + new_object->data.file[0] = (void *)((u32)fileptr+(u32)data->file[0]); + new_object->data.file[1] = (void *)((u32)fileptr+(u32)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; + new_object->data.base.rot.x = data->base.rot.x; + new_object->data.base.rot.y = data->base.rot.y; + new_object->data.base.rot.z = data->base.rot.z; + new_object->data.base.scale.x = data->base.scale.x; + new_object->data.base.scale.y = data->base.scale.y; + new_object->data.base.scale.z = data->base.scale.z; + new_object->data.mesh.min.x = data->mesh.min.x; + new_object->data.mesh.min.y = data->mesh.min.y; + new_object->data.mesh.min.z = data->mesh.min.z; + new_object->data.mesh.max.x = data->mesh.max.x; + new_object->data.mesh.max.y = data->mesh.max.y; + new_object->data.mesh.max.z = data->mesh.max.z; + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + case 0: + { + HsfObjectData *data; + HsfObject *new_object; + data = &object->data; + 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]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + if(Model.root == NULL) { + Model.root = temp_object; + } + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + case 1: + { + HsfObjectData *data; + HsfObject *new_object; + data = &object->data; + 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]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + if(Model.root == NULL) { + Model.root = temp_object; + } + new_object->data.unk64 = &objtop[(u32)new_object->data.unk64]; + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + + + case 3: + { + HsfObjectData *data; + HsfObject *new_object; + data = &object->data; + 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]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + if(Model.root == NULL) { + Model.root = temp_object; + } + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + case 4: + { + HsfObjectData *data; + HsfObject *new_object; + data = &object->data; + 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]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + if(Model.root == NULL) { + Model.root = temp_object; + } + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + case 5: + { + HsfObjectData *data; + HsfObject *new_object; + data = &object->data; + 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]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + if(Model.root == NULL) { + Model.root = temp_object; + } + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + case 9: + { + HsfObjectData *data; + HsfObject *new_object; + data = &object->data; + 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]; + for(i=0; idata.childrenCount; i++) { + child_obj = &objtop[(u32)new_object->data.children[i]]; + new_object->data.children[i] = child_obj; + } + if(Model.root == NULL) { + Model.root = temp_object; + } + for(i=0; ichildrenCount; i++) { + DispObject(new_object, new_object->data.children[i]); + } + } + break; + + default: + break; + } +} + +static s32 SearchObjectSetName(HsfData *data, char *name) +{ + HsfObject *object = data->object; + s32 i; + for(i=0; iobjectCnt; i++, object++) { + char *other_name = object->name; + int unk8 = 0; + if(!strcmp(other_name, name)) { + return i; + } + } + OSReport("Search Object Error %s\n", name); + return -1; +} + +static HsfBuffer *SearchVertexPtr(s32 id) +{ + HsfBuffer *vertex; + if(id == -1) { + return NULL; + } + vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs); + vertex += id; + return vertex; +} + +static HsfBuffer *SearchNormalPtr(s32 id) +{ + HsfBuffer *normal; + if(id == -1) { + return NULL; + } + normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs); + normal += id; + return normal; +} + +static HsfBuffer *SearchStPtr(s32 id) +{ + HsfBuffer *st; + if(id == -1) { + return NULL; + } + st = (HsfBuffer *)((u32)fileptr+head.st.ofs); + st += id; + return st; +} + +static HsfBuffer *SearchColorPtr(s32 id) +{ + HsfBuffer *color; + if(id == -1) { + return NULL; + } + color = (HsfBuffer *)((u32)fileptr+head.color.ofs); + color += id; + return color; +} + +static HsfBuffer *SearchFacePtr(s32 id) +{ + HsfBuffer *face; + if(id == -1) { + return NULL; + } + face = (HsfBuffer *)((u32)fileptr+head.face.ofs); + face += id; + return face; +} + +static HsfCenv *SearchCenvPtr(s32 id) +{ + HsfCenv *cenv; + if(id == -1) { + return NULL; + } + cenv = (HsfCenv *)((u32)fileptr+head.cenv.ofs); + cenv += id; + return cenv; +} + +static HsfPart *SearchPartPtr(s32 id) +{ + HsfPart *part; + if(id == -1) { + return NULL; + } + part = (HsfPart *)((u32)fileptr+head.part.ofs); + part += id; + return part; +} + +static HsfPalette *SearchPalettePtr(s32 id) +{ + HsfPalette *palette; + if(id == -1) { + return NULL; + } + palette = Model.palette; + palette += id; + return palette; +} + static HsfBitmap *SearchBitmapPtr(s32 id) { HsfBitmap *bitmap; From 95d01254bee0b065b80d19f129f47791ec6347d6 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 10:27:01 -0600 Subject: [PATCH 08/23] Match DispObject --- src/game/hsfload.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 93df141f..42b07a83 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -403,17 +403,17 @@ static void FaceLoad(void) static void DispObject(HsfObject *parent, HsfObject *object) { - u32 i; HsfObject *child_obj; - HsfObject *temp_object; - - HsfCluster *temp_cluster; - HsfObject *temp_parent = parent; - HsfBuffer *shape; + struct { + HsfObject *parent; + HsfBuffer *shape; + HsfCluster *cluster; + } temp; + temp.parent = parent; object->type = object->type; switch(object->type) { case 2: @@ -441,13 +441,13 @@ static void DispObject(HsfObject *parent, HsfObject *object) new_object->data.face = SearchFacePtr((s32)data->face); new_object->data.vertexShape = (HsfBuffer **)&NSymIndex[(u32)data->vertexShape]; for(i=0; idata.vertexShapeCnt; i++) { - HsfBuffer *shape = &vtxtop[(u32)new_object->data.vertexShape[i]]; - new_object->data.vertexShape[i] = shape; + temp.shape = &vtxtop[(u32)new_object->data.vertexShape[i]]; + new_object->data.vertexShape[i] = temp.shape; } new_object->data.cluster = (HsfCluster **)&NSymIndex[(u32)data->cluster]; for(i=0; idata.clusterCnt; i++) { - temp_cluster = &ClusterTop[(u32)new_object->data.cluster[i]]; - new_object->data.cluster[i] = temp_cluster; + temp.cluster = &ClusterTop[(u32)new_object->data.cluster[i]]; + new_object->data.cluster[i] = temp.cluster; } new_object->data.cenv = SearchCenvPtr((s32)data->cenv); new_object->data.material = Model.material; From 48d707f23cafe6903e2bcf800fd2f7480ecdab1a Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 10:43:52 -0600 Subject: [PATCH 09/23] Match ObjectLoad --- include/game/hsfformat.h | 2 +- src/game/hsfload.c | 62 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 60 insertions(+), 4 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index a8a0fb33..f2a9412c 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -189,7 +189,7 @@ typedef struct hsf_object_data { typedef struct hsf_object { char *name; - u32 type; + s32 type; HsfConstData *constData; u32 flags; HsfObjectData data; diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 42b07a83..7c3f0322 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -412,7 +412,6 @@ static void DispObject(HsfObject *parent, HsfObject *object) HsfCluster *cluster; } temp; - temp.parent = parent; object->type = object->type; switch(object->type) { @@ -523,9 +522,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } } break; - - case 3: { HsfObjectData *data; @@ -619,6 +616,65 @@ static void DispObject(HsfObject *parent, HsfObject *object) } } +static inline void FixupObject(HsfObject *object) +{ + HsfObjectData *objdata_8; + HsfObjectData *objdata_7; + + s32 obj_type = object->type; + switch(obj_type) { + case 8: + { + objdata_8 = &object->data; + object->type = 8; + } + break; + + case 7: + { + objdata_7 = &object->data; + object->type = 7; + } + break; + + default: + break; + + } +} + +static void ObjectLoad(void) +{ + s32 i; + HsfObject *object; + HsfObject *new_object; + + + s32 obj_type; + + + + if(head.object.count) { + objtop = object = (HsfObject *)((u32)fileptr+head.object.ofs); + for(i=0; iname = SetName((u32 *)&object->name); + } + object = objtop; + for(i=0; idata.parent == -1) { + break; + } + } + DispObject(NULL, object); + Model.objectCnt = head.object.count; + object = objtop; + for(i=0; iobject; From e233107006c0ead17d8c16773c620e909a96e5c4 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 12:15:59 -0600 Subject: [PATCH 10/23] Decompile CenvLoad and SkeletonLoad --- include/game/hsfformat.h | 58 +++++++++++++++++- src/game/hsfload.c | 128 ++++++++++++++++++++++++++++++++++----- 2 files changed, 170 insertions(+), 16 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index f2a9412c..f9f87513 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -3,6 +3,17 @@ #include "dolphin.h" +#define HSF_OBJTYPE_NULL1 0 +#define HSF_OBJTYPE_REPLICA 1 +#define HSF_OBJTYPE_MESH 2 +#define HSF_OBJTYPE_ROOT 3 +#define HSF_OBJTYPE_JOINT 4 +#define HSF_OBJTYPE_NULL2 5 +#define HSF_OBJTYPE_NULL3 6 +#define HSF_OBJTYPE_NONE1 7 +#define HSF_OBJTYPE_NONE2 8 +#define HSF_OBJTYPE_MAP 9 + typedef struct hsf_vector3f { float x; float y; @@ -132,8 +143,53 @@ typedef struct hsf_transform { HsfVector3f scale; } HsfTransform; +typedef struct hsf_cenv_single { + u32 target; + u16 pos; + u16 posCnt; + u16 normal; + u16 normalCnt; +} HsfCenvSingle; + +typedef struct hsf_cenv_dual_weight { + float weight; + u16 pos; + u16 posCnt; + u16 normal; + u16 normalCnt; +} HsfCenvDualWeight; + +typedef struct hsf_cenv_dual { + u32 target1; + u32 target2; + u32 weightCnt; + HsfCenvDualWeight *weight; +} HsfCenvDual; + +typedef struct hsf_cenv_multi_weight { + u32 target; + float value; +} HsfCenvMultiWeight; + +typedef struct hsf_cenv_multi { + u32 weightCnt; + u16 pos; + u16 posCnt; + u16 normal; + u16 normalCnt; + HsfCenvMultiWeight *weight; +} HsfCenvMulti; + typedef struct hsf_cenv { - u8 unk[36]; + char *name; + HsfCenvSingle *singleData; + HsfCenvDual *dualData; + HsfCenvMulti *multiData; + u32 singleCount; + u32 dualCount; + u32 multiCount; + u32 vtxCount; + u32 copyCount; } HsfCenv; typedef struct hsf_part { diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 7c3f0322..27762064 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -415,7 +415,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) temp.parent = parent; object->type = object->type; switch(object->type) { - case 2: + case HSF_OBJTYPE_MESH: { HsfObjectData *data; HsfObject *new_object; @@ -432,7 +432,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) if(Model.root == NULL) { Model.root = temp_object; } - new_object->type = 2; + new_object->type = HSF_OBJTYPE_MESH; new_object->data.vertex = SearchVertexPtr((s32)data->vertex); new_object->data.normal = SearchNormalPtr((s32)data->normal); new_object->data.st = SearchStPtr((s32)data->st); @@ -478,7 +478,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case 0: + case HSF_OBJTYPE_NULL1: { HsfObjectData *data; HsfObject *new_object; @@ -500,7 +500,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case 1: + case HSF_OBJTYPE_REPLICA: { HsfObjectData *data; HsfObject *new_object; @@ -523,7 +523,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case 3: + case HSF_OBJTYPE_ROOT: { HsfObjectData *data; HsfObject *new_object; @@ -545,7 +545,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case 4: + case HSF_OBJTYPE_JOINT: { HsfObjectData *data; HsfObject *new_object; @@ -567,7 +567,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case 5: + case HSF_OBJTYPE_NULL2: { HsfObjectData *data; HsfObject *new_object; @@ -589,7 +589,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case 9: + case HSF_OBJTYPE_MAP: { HsfObjectData *data; HsfObject *new_object; @@ -626,14 +626,14 @@ static inline void FixupObject(HsfObject *object) case 8: { objdata_8 = &object->data; - object->type = 8; + object->type = HSF_OBJTYPE_NONE2; } break; case 7: { objdata_7 = &object->data; - object->type = 7; + object->type = HSF_OBJTYPE_NONE1; } break; @@ -648,12 +648,8 @@ static void ObjectLoad(void) s32 i; HsfObject *object; HsfObject *new_object; - - s32 obj_type; - - - + if(head.object.count) { objtop = object = (HsfObject *)((u32)fileptr+head.object.ofs); for(i=0; iobject; From 8c14475c86f78ddd74fb163a205328a2849b2fa2 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 14:48:53 -0600 Subject: [PATCH 11/23] Decompile up to BitmapLoad --- include/game/hsfformat.h | 42 +++++++++---- src/game/hsfload.c | 126 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 154 insertions(+), 14 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index f9f87513..505ab6ba 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -134,7 +134,7 @@ typedef struct hsf_face { typedef struct hsf_const_data { u32 flags; - u8 unk[64]; + u8 unk4[64]; } HsfConstData; typedef struct hsf_transform { @@ -195,20 +195,31 @@ typedef struct hsf_cenv { typedef struct hsf_part { char *name; u32 count; - u16 *data; + u16 *vertex; } HsfPart; typedef struct hsf_cluster { - char *name[3]; + char *name[2]; + union { + char *targetName; + u32 target; + }; HsfPart *part; - u8 unk[144]; + u8 unk10[132]; + u8 adjusted; + u8 unk95; + u16 type; + u32 vertexCnt; + HsfBuffer **vertex; } HsfCluster; typedef struct hsf_shape { char *name; - u16 count1; - u16 morphTargetCnt; - HsfBuffer **morphTargets; + union { + u16 count16[2]; + u32 vertexCnt; + }; + HsfBuffer **vertex; } HsfShape; typedef struct hsf_object_data { @@ -221,9 +232,10 @@ typedef struct hsf_object_data { struct { HsfVector3f min; HsfVector3f max; - u8 unk[136]; + float baseMorph; + float *morphWeight[33]; } mesh; - struct hsf_object *unk64; + struct hsf_object *replica; }; HsfBuffer *face; @@ -233,7 +245,8 @@ typedef struct hsf_object_data { HsfBuffer *st; HsfMaterial *material; HsfAttribute *attribute; - u8 unk2[4]; + u8 unk120[2]; + u8 shapeType; u32 vertexShapeCnt; HsfBuffer **vertexShape; u32 clusterCnt; @@ -275,9 +288,12 @@ typedef struct hsf_motion { } HsfMotion; typedef struct hsf_map_attr { - u8 unk[16]; - void *unk10; - u8 unk2[4]; + float min_x; + float min_z; + float max_x; + float max_z; + s16 *data; + u32 dataLen; } HsfMapAttr; typedef struct hsf_matrix { diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 27762064..94b1b915 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -41,6 +41,7 @@ static void BitmapLoad(void); static void MotionLoad(void); static void MatrixLoad(void); +static s32 SearchObjectSetName(HsfData *data, char *name); static HsfBuffer *SearchVertexPtr(s32 id); static HsfBuffer *SearchNormalPtr(s32 id); static HsfBuffer *SearchStPtr(s32 id); @@ -85,6 +86,27 @@ HsfData *LoadHSF(void *data) } +void ClusterAdjustObject(HsfData *src_model, HsfData *model) +{ + HsfCluster *cluster; + s32 i; + if(!model) { + return; + } + if(model->clusterCnt == 0) { + return; + } + cluster = model->cluster; + if(cluster->adjusted) { + return; + } + cluster->adjusted = 1; + for(i=0; iclusterCnt; i++, cluster++) { + char *name = cluster->targetName; + cluster->target = SearchObjectSetName(src_model, name); + } +} + static void FileLoad(void *data) { fileptr = data; @@ -516,7 +538,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) if(Model.root == NULL) { Model.root = temp_object; } - new_object->data.unk64 = &objtop[(u32)new_object->data.unk64]; + new_object->data.replica = &objtop[(u32)new_object->data.replica]; for(i=0; ichildrenCount; i++) { DispObject(new_object, new_object->data.children[i]); } @@ -773,6 +795,108 @@ static void SkeletonLoad(void) } } +static void PartLoad(void) +{ + HsfPart *part_file; + HsfPart *part_new; + + u16 *data; + s32 i, j; + + if(head.part.count) { + part_new = part_file = (HsfPart *)((u32)fileptr+head.part.ofs); + Model.partCnt = head.part.count; + Model.part = part_file; + data = (u16 *)&part_file[head.part.count]; + for(i=0; iname = SetName((u32 *)&part_file[i].name); + part_new->count = part_file[i].count; + part_new->vertex = &data[(u32)part_file[i].vertex]; + for(j=0; jcount; j++) { + part_new->vertex[j] = part_new->vertex[j]; + } + } + } +} + +static void ClusterLoad(void) +{ + HsfCluster *cluster_file; + HsfCluster *cluster_new; + + s32 i, j; + + if(head.cluster.count) { + cluster_new = cluster_file = (HsfCluster *)((u32)fileptr+head.cluster.ofs); + Model.clusterCnt = head.cluster.count; + Model.cluster = cluster_file; + for(i=0; idata = &data[(u32)mapattr_file->data]; + } + } +} + static s32 SearchObjectSetName(HsfData *data, char *name) { HsfObject *object = data->object; From b57ad97bf6d7dec8eae42ab23fa82aef29924027 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 17:39:07 -0600 Subject: [PATCH 12/23] Match most functions in hsfload.c --- include/game/hsfformat.h | 24 ++++++----- src/game/hsfload.c | 87 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+), 10 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 505ab6ba..427f7b69 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -67,9 +67,9 @@ typedef struct hsf_bitmap { s32 maxLod; u8 dataFmt; u8 pixSize; - u16 w; - u16 h; - u16 palSize; + s16 sizeX; + s16 sizeY; + s16 palSize; GXColor tint; void *palData; u32 unk; @@ -79,13 +79,17 @@ typedef struct hsf_bitmap { typedef struct hsf_palette { char *name; s32 unk; - s32 palSize; - void *data; + u32 palSize; + u16 *data; } HsfPalette; typedef struct hsf_attribute { char *name; - u8 unk[124]; + u8 unk4[96]; + u32 wrap_s; + u32 wrap_t; + u8 unk6C[16]; + u32 flag; HsfBitmap *bitmap; } HsfAttribute; @@ -288,10 +292,10 @@ typedef struct hsf_motion { } HsfMotion; typedef struct hsf_map_attr { - float min_x; - float min_z; - float max_x; - float max_z; + float minX; + float minZ; + float maxX; + float maxZ; s16 *data; u32 dataLen; } HsfMapAttr; diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 94b1b915..976bc113 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -877,6 +877,93 @@ static void ShapeLoad(void) } } +static void BitmapLoad(void) +{ + HsfBitmap *bitmap_file; + HsfBitmap *bitmap_temp; + HsfBitmap *bitmap_new; + HsfPalette *palette; + void *data; + s32 i; + + if(head.bitmap.count) { + bitmap_temp = bitmap_file = (HsfBitmap *)((u32)fileptr+head.bitmap.ofs); + data = &bitmap_file[head.bitmap.count]; + for(i=0; iname = SetName((u32 *)&bitmap_file->name); + bitmap_new->dataFmt = bitmap_file->dataFmt; + bitmap_new->pixSize = bitmap_file->pixSize; + bitmap_new->sizeX = bitmap_file->sizeX; + bitmap_new->sizeY = bitmap_file->sizeY; + bitmap_new->palSize = bitmap_file->palSize; + palette = SearchPalettePtr((u32)bitmap_file->palData); + if(palette) { + bitmap_new->palData = palette->data; + } + bitmap_new->data = (void *)((u32)data+(u32)bitmap_file->data); + } + } +} + +static void PaletteLoad(void) +{ + s32 i; + s32 j; + HsfPalette *palette_file; + HsfPalette *palette_temp; + HsfPalette *palette_new; + + void *data_base; + u16 *temp_data; + u16 *data; + + if(head.palette.count) { + palette_temp = palette_file = (HsfPalette *)((u32)fileptr+head.palette.ofs); + data_base = (u16 *)&palette_file[head.palette.count]; + for(i=0; idata); + } + Model.palette = palette_temp; + Model.paletteCnt = head.palette.count; + palette_new = palette_temp; + palette_file = (HsfPalette *)((u32)fileptr+head.palette.ofs); + data_base = (u16 *)&palette_file[head.palette.count]; + for(i=0; idata); + data = temp_data; + palette_new->name = SetName((u32 *)&palette_file->name); + palette_new->data = data; + palette_new->palSize = palette_file->palSize; + for(j=0; jpalSize; j++) { + data[j] = data[j]; + } + } + } +} + +static void MotionLoad(void) +{ + +} + +static void MatrixLoad(void) +{ + HsfMatrix *matrix_file; + + if(head.matrix.count) { + matrix_file = (HsfMatrix *)((u32)fileptr+head.matrix.ofs); + matrix_file->data = (Mtx *)((u32)fileptr+head.matrix.ofs+sizeof(HsfMatrix)); + Model.matrix = matrix_file; + Model.matrixCnt = head.matrix.count; + } +} + static void MapAttrLoad(void) { s32 i; From 4f4cc47d0e4d7fba8dffe0e8b8851bf4d79bb440 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 17:51:34 -0600 Subject: [PATCH 13/23] Match all but MotionLoad --- include/ctype.h | 51 ++++++++++++++++++++++++++++++++++++++++++++++ src/game/hsfload.c | 38 ++++++++++++++++++++++++++++++++++ 2 files changed, 89 insertions(+) create mode 100644 include/ctype.h diff --git a/include/ctype.h b/include/ctype.h new file mode 100644 index 00000000..559e7278 --- /dev/null +++ b/include/ctype.h @@ -0,0 +1,51 @@ +#ifndef _CTYPE_H +#define _CTYPE_H + + +extern unsigned char __ctype_map[256]; +extern unsigned char __lower_map[256]; +extern unsigned char __upper_map[256]; + +#define __control_char 0x01 +#define __motion_char 0x02 +#define __space_char 0x04 +#define __punctuation 0x08 +#define __digit 0x10 +#define __hex_digit 0x20 +#define __lower_case 0x40 +#define __upper_case 0x80 + +#define __letter (__lower_case | __upper_case) +#define __alphanumeric (__letter | __digit) +#define __graphic (__alphanumeric | __punctuation) +#define __printable (__graphic | __space_char) +#define __whitespace (__motion_char | __space_char) +#define __control (__motion_char | __control_char) + +#ifdef __cplusplus +extern "C" +{ +#endif + + __declspec(weak) int isalpha(int __c); + __declspec(weak) int isdigit(int __c); + __declspec(weak) int isspace(int __c); + __declspec(weak) int isupper(int __c); + __declspec(weak) int isxdigit(int __c); + + __declspec(weak) int tolower(int __c); + __declspec(weak) int toupper(int __c); + + // added underscore to avoid naming conflicts + inline int _isalpha(int c) { return (int)(__ctype_map[(u8)c] & __letter); } + inline int _isdigit(int c) { return (int)(__ctype_map[(u8)c] & __digit); } + inline int _isspace(int c) { return (int)(__ctype_map[(u8)c] & __whitespace); } + inline int _isupper(int c) { return (int)(__ctype_map[(u8)c] & __upper_case); } + inline int _isxdigit(int c) { return (int)(__ctype_map[(u8)c] & __hex_digit); } + inline int _tolower(int c) { return (c == -1 ? -1 : (int)__lower_map[(u8)c]); } + inline int _toupper(int c) { return (c == -1 ? -1 : (int)__upper_map[(u8)c]); } + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 976bc113..7c48e550 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1,5 +1,6 @@ #include "game/hsfformat.h" #include "string.h" +#include "ctype.h" GXColor rgba[100]; HsfHeader head; @@ -947,6 +948,43 @@ static void PaletteLoad(void) } } +char *MakeObjectName(char *name) +{ + static char buf[768]; + int index, num_minus; + char *temp_name; + num_minus = 0; + index = 0; + temp_name = name; + while(*temp_name) { + if(*temp_name == '-') { + name = temp_name+1; + break; + } + temp_name++; + } + while(*name) { + if(num_minus != 0) { + break; + } + if(*name == '_' && !isalpha(name[1])) { + num_minus++; + break; + } + buf[index] = *name; + name++; + index++; + } + buf[index] = '\0'; + return buf; +} + +int CmpObjectName(char *name1, char *name2) +{ + int temp = 0; + return strcmp(name1, name2); +} + static void MotionLoad(void) { From d372b1c596562cb141e3608c4d27d7a720f945c7 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Mon, 4 Dec 2023 22:48:51 -0600 Subject: [PATCH 14/23] Start decompiling MotionLoad --- include/game/hsfformat.h | 57 ++++-- src/game/hsfload.c | 363 +++++++++++++++++++++++++++++++++++++-- 2 files changed, 392 insertions(+), 28 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 427f7b69..513ac699 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -3,16 +3,29 @@ #include "dolphin.h" -#define HSF_OBJTYPE_NULL1 0 -#define HSF_OBJTYPE_REPLICA 1 -#define HSF_OBJTYPE_MESH 2 -#define HSF_OBJTYPE_ROOT 3 -#define HSF_OBJTYPE_JOINT 4 -#define HSF_OBJTYPE_NULL2 5 -#define HSF_OBJTYPE_NULL3 6 -#define HSF_OBJTYPE_NONE1 7 -#define HSF_OBJTYPE_NONE2 8 -#define HSF_OBJTYPE_MAP 9 +#define HSF_OBJ_NULL1 0 +#define HSF_OBJ_REPLICA 1 +#define HSF_OBJ_MESH 2 +#define HSF_OBJ_ROOT 3 +#define HSF_OBJ_JOINT 4 +#define HSF_OBJ_NULL2 5 +#define HSF_OBJ_NULL3 6 +#define HSF_OBJ_NONE1 7 +#define HSF_OBJ_NONE2 8 +#define HSF_OBJ_MAP 9 + +#define HSF_TRACK_TRANSFORM 2 +#define HSF_TRACK_MORPH 3 +#define HSF_TRACK_CLUSTER 5 +#define HSF_TRACK_CLUSTER_WEIGHT 6 +#define HSF_TRACK_MATERIAL 9 +#define HSF_TRACK_ATTRIBUTE 10 + +#define HSF_CURVE_STEP 0 +#define HSF_CURVE_LINEAR 1 +#define HSF_CURVE_BEZIER 2 +#define HSF_CURVE_BITMAP 3 +#define HSF_CURVE_CONST 4 typedef struct hsf_vector3f { float x; @@ -273,15 +286,23 @@ typedef struct hsf_skeleton { HsfTransform transform; } HsfSkeleton; +typedef struct hsf_bitmap_keyframe { + float time; + HsfBitmap *data; +} HsfBitmapKey; + typedef struct hsf_track { - u8 mode; - u8 value; - s16 idx; - s16 type; - s16 effect; - s16 curveType; - s16 numKeyframes; - void *data; + u8 type; + u8 start; + u16 target; + u16 param; + u16 channel; + u16 curveType; + u16 numKeyframes; + union { + float value; + void *data; + }; } HsfTrack; typedef struct hsf_motion { diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 7c48e550..da7a58e9 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -2,6 +2,7 @@ #include "string.h" #include "ctype.h" +#define AS_S16(field) (*((s16 *)&(field))) GXColor rgba[100]; HsfHeader head; HsfData Model; @@ -54,6 +55,7 @@ static HsfPalette *SearchPalettePtr(s32 id); static HsfBitmap *SearchBitmapPtr(s32 id); static char *GetString(u32 *str_ofs); +static char *GetMotionString(u16 *str_ofs); HsfData *LoadHSF(void *data) { @@ -171,6 +173,12 @@ char *SetName(u32 *str_ofs) return ret; } +static inline char *SetMotionName(u16 *str_ofs) +{ + char *ret = GetMotionString(str_ofs); + return ret; +} + static void MaterialLoad(void) { s32 i; @@ -438,7 +446,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) temp.parent = parent; object->type = object->type; switch(object->type) { - case HSF_OBJTYPE_MESH: + case HSF_OBJ_MESH: { HsfObjectData *data; HsfObject *new_object; @@ -455,7 +463,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) if(Model.root == NULL) { Model.root = temp_object; } - new_object->type = HSF_OBJTYPE_MESH; + new_object->type = HSF_OBJ_MESH; new_object->data.vertex = SearchVertexPtr((s32)data->vertex); new_object->data.normal = SearchNormalPtr((s32)data->normal); new_object->data.st = SearchStPtr((s32)data->st); @@ -501,7 +509,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case HSF_OBJTYPE_NULL1: + case HSF_OBJ_NULL1: { HsfObjectData *data; HsfObject *new_object; @@ -523,7 +531,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case HSF_OBJTYPE_REPLICA: + case HSF_OBJ_REPLICA: { HsfObjectData *data; HsfObject *new_object; @@ -546,7 +554,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case HSF_OBJTYPE_ROOT: + case HSF_OBJ_ROOT: { HsfObjectData *data; HsfObject *new_object; @@ -568,7 +576,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case HSF_OBJTYPE_JOINT: + case HSF_OBJ_JOINT: { HsfObjectData *data; HsfObject *new_object; @@ -590,7 +598,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case HSF_OBJTYPE_NULL2: + case HSF_OBJ_NULL2: { HsfObjectData *data; HsfObject *new_object; @@ -612,7 +620,7 @@ static void DispObject(HsfObject *parent, HsfObject *object) } break; - case HSF_OBJTYPE_MAP: + case HSF_OBJ_MAP: { HsfObjectData *data; HsfObject *new_object; @@ -649,14 +657,14 @@ static inline void FixupObject(HsfObject *object) case 8: { objdata_8 = &object->data; - object->type = HSF_OBJTYPE_NONE2; + object->type = HSF_OBJ_NONE2; } break; case 7: { objdata_7 = &object->data; - object->type = HSF_OBJTYPE_NONE1; + object->type = HSF_OBJ_NONE1; } break; @@ -985,9 +993,344 @@ int CmpObjectName(char *name1, char *name2) return strcmp(name1, name2); } +static inline char *MotionGetName(HsfTrack *track) +{ + char *ret; + if(DicStringTable) { + ret = &DicStringTable[track->target]; + } else { + ret = GetMotionString(&track->target); + } + return ret; +} + +static inline s32 FindObjectName(char *name) +{ + s32 i; + HsfObject *object; + + object = objtop; + for(i=0; iname; + int unk = 0; + if(!strcmp(other_name, name)) { + return i; + } + } + return -1; +} + +static inline s32 FindClusterName(char *name) +{ + s32 i; + HsfCluster *cluster; + + cluster = ClusterTop; + for(i=0; iname[0], name)) { + return i; + } + } + return -1; +} + +static inline int FindMotionClusterName(char *name) +{ + s32 i; + HsfCluster *cluster; + + cluster = MotionModel->cluster; + for(i=0; iclusterCnt; i++, cluster++) { + if(!strcmp(cluster->name[0], name)) { + return i; + } + } + return -1; +} + +static inline s32 FindAttributeName(char *name) +{ + s32 i; + HsfAttribute *attribute; + + attribute = AttributeTop; + for(i=0; iname) { + continue; + } + if(!strcmp(attribute->name, name)) { + return i; + } + } + return -1; +} + +static inline int FindMotionAttributeName(char *name) +{ + s32 i; + HsfAttribute *attribute; + + attribute = MotionModel->attribute; + for(i=0; iattributeCnt; i++, attribute++) { + if(!attribute->name) { + continue; + } + if(!strcmp(attribute->name, name)) { + return i; + } + } + return -1; +} + +static inline void MotionLoadTransform(HsfTrack *track, void *data) +{ + HsfTrack *out_track; + char *name; + s32 numKeyframes; + out_track = track; + name = MotionGetName(track); + if(objtop) { + out_track->target = FindObjectName(name); + } + numKeyframes = AS_S16(track->numKeyframes); + switch(track->curveType) { + case HSF_CURVE_STEP: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_LINEAR: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_BEZIER: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_CONST: + break; + } +} + +static inline void MotionLoadCluster(HsfTrack *track, void *data) +{ + HsfTrack *out_track; + char *name; + s32 numKeyframes; + out_track = track; + name = SetMotionName(&track->target); + if(!MotionOnly) { + AS_S16(out_track->target) = FindClusterName(name); + } else { + AS_S16(out_track->target) = FindMotionClusterName(name); + } + numKeyframes = AS_S16(track->numKeyframes); + switch(track->curveType) { + case HSF_CURVE_STEP: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_LINEAR: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_BEZIER: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_CONST: + break; + } +} + +static inline void MotionLoadClusterWeight(HsfTrack *track, void *data) +{ + HsfTrack *out_track; + char *name; + s32 numKeyframes; + out_track = track; + name = SetMotionName(&track->target); + if(!MotionOnly) { + AS_S16(out_track->target) = FindClusterName(name); + } else { + AS_S16(out_track->target) = FindMotionClusterName(name); + } + numKeyframes = AS_S16(track->numKeyframes); + switch(track->curveType) { + case HSF_CURVE_STEP: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_LINEAR: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_BEZIER: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_CONST: + break; + } +} + +static inline void MotionLoadMaterial(HsfTrack *track, void *data) +{ + s32 numKeyframes; + HsfTrack *out_track; + out_track = track; + numKeyframes = AS_S16(track->numKeyframes); + switch(track->curveType) { + case HSF_CURVE_STEP: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_LINEAR: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_BEZIER: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_CONST: + break; + } +} + +static inline void MotionLoadAttribute(HsfTrack *track, void *data) +{ + HsfTrack *out_track; + char *name; + out_track = track; + if(AS_S16(out_track->target) != -1) { + name = SetMotionName(&track->target); + if(!MotionOnly) { + AS_S16(out_track->param) = FindAttributeName(name); + } else { + AS_S16(out_track->param) = FindMotionAttributeName(name); + } + } + + switch(track->curveType) { + case HSF_CURVE_STEP: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_LINEAR: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_BEZIER: + { + void *temp_data = (void *)((u32)data+(u32)track->data); + out_track->data = temp_data; + } + break; + + case HSF_CURVE_BITMAP: + { + HsfBitmapKey *file_frame; + HsfBitmapKey *new_frame; + s32 i; + new_frame = file_frame = (HsfBitmapKey *)((u32)data+(u32)track->data); + out_track->data = file_frame; + for(i=0; inumKeyframes; i++, file_frame++, new_frame++) { + new_frame->data = SearchBitmapPtr((s32)file_frame->data); + } + } + break; + case HSF_CURVE_CONST: + break; + } +} + + static void MotionLoad(void) { + HsfMotion *file_motion; + HsfMotion *temp_motion; + HsfMotion *new_motion; + HsfTrack *track_base; + void *track_data; + s32 i; + MotionOnly = FALSE; + MotionModel = NULL; + if(head.motion.count) { + temp_motion = file_motion = (HsfMotion *)((u32)fileptr+head.motion.ofs); + new_motion = temp_motion; + Model.motion = new_motion; + Model.motionCnt = file_motion->numTracks; + track_base = (HsfTrack *)&file_motion[head.motion.count]; + track_data = &track_base[file_motion->numTracks]; + new_motion->track = track_base; + for(i=0; i<(s32)file_motion->numTracks; i++) { + switch(track_base[i].type) { + case HSF_TRACK_TRANSFORM: + case HSF_TRACK_MORPH: + MotionLoadTransform(&track_base[i], track_data); + break; + + case HSF_TRACK_CLUSTER: + MotionLoadCluster(&track_base[i], track_data); + break; + + case HSF_TRACK_CLUSTER_WEIGHT: + MotionLoadClusterWeight(&track_base[i], track_data); + break; + + case HSF_TRACK_MATERIAL: + MotionLoadMaterial(&track_base[i], track_data); + break; + + case HSF_TRACK_ATTRIBUTE: + MotionLoadAttribute(&track_base[i], track_data); + break; + } + } + } } static void MatrixLoad(void) From 239df728daf246663f4e18bbdf8133c28606dd14 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 00:00:07 -0600 Subject: [PATCH 15/23] Improve MotionLoad --- src/game/hsfload.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index da7a58e9..51aa5579 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1004,6 +1004,12 @@ static inline char *MotionGetName(HsfTrack *track) return ret; } +static inline BOOL CompareName(char *name1, char *name2) +{ + int unk = 0; + return !strcmp(name1, name2); +} + static inline s32 FindObjectName(char *name) { s32 i; @@ -1011,9 +1017,7 @@ static inline s32 FindObjectName(char *name) object = objtop; for(i=0; iname; - int unk = 0; - if(!strcmp(other_name, name)) { + if(CompareName(object->name, name)) { return i; } } @@ -1328,9 +1332,13 @@ static void MotionLoad(void) case HSF_TRACK_ATTRIBUTE: MotionLoadAttribute(&track_base[i], track_data); break; + + default: + break; } } } + } static void MatrixLoad(void) @@ -1370,9 +1378,7 @@ static s32 SearchObjectSetName(HsfData *data, char *name) HsfObject *object = data->object; s32 i; for(i=0; iobjectCnt; i++, object++) { - char *other_name = object->name; - int unk8 = 0; - if(!strcmp(other_name, name)) { + if(CompareName(object->name, name)) { return i; } } From afd8fce01dda04d8f2781dab919a843f8f4b9a81 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 00:02:37 -0600 Subject: [PATCH 16/23] Use CmpObjectName instead --- src/game/hsfload.c | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 51aa5579..8537876e 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1004,12 +1004,6 @@ static inline char *MotionGetName(HsfTrack *track) return ret; } -static inline BOOL CompareName(char *name1, char *name2) -{ - int unk = 0; - return !strcmp(name1, name2); -} - static inline s32 FindObjectName(char *name) { s32 i; @@ -1017,7 +1011,7 @@ static inline s32 FindObjectName(char *name) object = objtop; for(i=0; iname, name)) { + if(!CmpObjectName(object->name, name)) { return i; } } @@ -1378,7 +1372,7 @@ static s32 SearchObjectSetName(HsfData *data, char *name) HsfObject *object = data->object; s32 i; for(i=0; iobjectCnt; i++, object++) { - if(CompareName(object->name, name)) { + if(!CmpObjectName(object->name, name)) { return i; } } From 83140bb79564b9ab13e27997dadf6dc643d0788e Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 00:46:10 -0600 Subject: [PATCH 17/23] Fully match MotionLoad Still some file issues --- src/game/hsfload.c | 115 ++++++++++++++++++++++++++++++--------------- 1 file changed, 78 insertions(+), 37 deletions(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 8537876e..bd50a3e5 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1082,6 +1082,9 @@ static inline int FindMotionAttributeName(char *name) static inline void MotionLoadTransform(HsfTrack *track, void *data) { + float *step_data; + float *linear_data; + float *bezier_data; HsfTrack *out_track; char *name; s32 numKeyframes; @@ -1094,22 +1097,22 @@ static inline void MotionLoadTransform(HsfTrack *track, void *data) switch(track->curveType) { case HSF_CURVE_STEP: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + step_data = (float *)((u32)data+(u32)track->data); + out_track->data = step_data; } break; case HSF_CURVE_LINEAR: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + linear_data = (float *)((u32)data+(u32)track->data); + out_track->data = linear_data; } break; case HSF_CURVE_BEZIER: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + bezier_data = (float *)((u32)data+(u32)track->data); + out_track->data = bezier_data; } break; @@ -1120,9 +1123,13 @@ static inline void MotionLoadTransform(HsfTrack *track, void *data) static inline void MotionLoadCluster(HsfTrack *track, void *data) { + s32 numKeyframes; + float *step_data; + float *linear_data; + float *bezier_data; HsfTrack *out_track; char *name; - s32 numKeyframes; + out_track = track; name = SetMotionName(&track->target); if(!MotionOnly) { @@ -1131,25 +1138,26 @@ static inline void MotionLoadCluster(HsfTrack *track, void *data) AS_S16(out_track->target) = FindMotionClusterName(name); } numKeyframes = AS_S16(track->numKeyframes); + (void)out_track; switch(track->curveType) { case HSF_CURVE_STEP: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + step_data = (float *)((u32)data+(u32)track->data); + out_track->data = step_data; } break; case HSF_CURVE_LINEAR: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + linear_data = (float *)((u32)data+(u32)track->data); + out_track->data = linear_data; } break; case HSF_CURVE_BEZIER: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + bezier_data = (float *)((u32)data+(u32)track->data); + out_track->data = bezier_data; } break; @@ -1160,9 +1168,13 @@ static inline void MotionLoadCluster(HsfTrack *track, void *data) static inline void MotionLoadClusterWeight(HsfTrack *track, void *data) { + s32 numKeyframes; + float *step_data; + float *linear_data; + float *bezier_data; HsfTrack *out_track; char *name; - s32 numKeyframes; + out_track = track; name = SetMotionName(&track->target); if(!MotionOnly) { @@ -1171,25 +1183,26 @@ static inline void MotionLoadClusterWeight(HsfTrack *track, void *data) AS_S16(out_track->target) = FindMotionClusterName(name); } numKeyframes = AS_S16(track->numKeyframes); + (void)out_track; switch(track->curveType) { case HSF_CURVE_STEP: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + step_data = (float *)((u32)data+(u32)track->data); + out_track->data = step_data; } break; case HSF_CURVE_LINEAR: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + linear_data = (float *)((u32)data+(u32)track->data); + out_track->data = linear_data; } break; case HSF_CURVE_BEZIER: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + bezier_data = (float *)((u32)data+(u32)track->data); + out_track->data = bezier_data; } break; @@ -1200,6 +1213,9 @@ static inline void MotionLoadClusterWeight(HsfTrack *track, void *data) static inline void MotionLoadMaterial(HsfTrack *track, void *data) { + float *step_data; + float *linear_data; + float *bezier_data; s32 numKeyframes; HsfTrack *out_track; out_track = track; @@ -1207,22 +1223,22 @@ static inline void MotionLoadMaterial(HsfTrack *track, void *data) switch(track->curveType) { case HSF_CURVE_STEP: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + step_data = (float *)((u32)data+(u32)track->data); + out_track->data = step_data; } break; case HSF_CURVE_LINEAR: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + linear_data = (float *)((u32)data+(u32)track->data); + out_track->data = linear_data; } break; case HSF_CURVE_BEZIER: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + bezier_data = (float *)((u32)data+(u32)track->data); + out_track->data = bezier_data; } break; @@ -1233,6 +1249,12 @@ static inline void MotionLoadMaterial(HsfTrack *track, void *data) static inline void MotionLoadAttribute(HsfTrack *track, void *data) { + HsfBitmapKey *file_frame; + HsfBitmapKey *new_frame; + s32 i; + float *step_data; + float *linear_data; + float *bezier_data; HsfTrack *out_track; char *name; out_track = track; @@ -1248,30 +1270,27 @@ static inline void MotionLoadAttribute(HsfTrack *track, void *data) switch(track->curveType) { case HSF_CURVE_STEP: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + step_data = (float *)((u32)data+(u32)track->data); + out_track->data = step_data; } break; case HSF_CURVE_LINEAR: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + linear_data = (float *)((u32)data+(u32)track->data); + out_track->data = linear_data; } break; case HSF_CURVE_BEZIER: { - void *temp_data = (void *)((u32)data+(u32)track->data); - out_track->data = temp_data; + bezier_data = (float *)((u32)data+(u32)track->data); + out_track->data = bezier_data; } break; case HSF_CURVE_BITMAP: { - HsfBitmapKey *file_frame; - HsfBitmapKey *new_frame; - s32 i; new_frame = file_frame = (HsfBitmapKey *)((u32)data+(u32)track->data); out_track->data = file_frame; for(i=0; inumKeyframes; i++, file_frame++, new_frame++) { @@ -1284,7 +1303,6 @@ static inline void MotionLoadAttribute(HsfTrack *track, void *data) } } - static void MotionLoad(void) { HsfMotion *file_motion; @@ -1332,7 +1350,30 @@ static void MotionLoad(void) } } } - + //HACK: Bump register of i to r31 + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; + (void)i; } static void MatrixLoad(void) From 5754048056112e6f93291d28d76069643f480df8 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 00:48:36 -0600 Subject: [PATCH 18/23] Fix ordering issues --- src/game/hsfload.c | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/game/hsfload.c b/src/game/hsfload.c index bd50a3e5..65b23684 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -886,6 +886,26 @@ static void ShapeLoad(void) } } +static void MapAttrLoad(void) +{ + s32 i; + HsfMapAttr *mapattr_base; + HsfMapAttr *mapattr_file; + HsfMapAttr *mapattr_new; + s16 *data; + + if(head.mapAttr.count) { + mapattr_file = mapattr_base = (HsfMapAttr *)((u32)fileptr+head.mapAttr.ofs); + mapattr_new = mapattr_base; + Model.mapAttrCnt = head.mapAttr.count; + Model.mapAttr = mapattr_base; + data = (s16 *)&mapattr_base[head.mapAttr.count]; + for(i=0; idata = &data[(u32)mapattr_file->data]; + } + } +} + static void BitmapLoad(void) { HsfBitmap *bitmap_file; @@ -1388,26 +1408,6 @@ static void MatrixLoad(void) } } -static void MapAttrLoad(void) -{ - s32 i; - HsfMapAttr *mapattr_base; - HsfMapAttr *mapattr_file; - HsfMapAttr *mapattr_new; - s16 *data; - - if(head.mapAttr.count) { - mapattr_file = mapattr_base = (HsfMapAttr *)((u32)fileptr+head.mapAttr.ofs); - mapattr_new = mapattr_base; - Model.mapAttrCnt = head.mapAttr.count; - Model.mapAttr = mapattr_base; - data = (s16 *)&mapattr_base[head.mapAttr.count]; - for(i=0; idata = &data[(u32)mapattr_file->data]; - } - } -} - static s32 SearchObjectSetName(HsfData *data, char *name) { HsfObject *object = data->object; From 0b6390b8f2949b6d4245fea42f71ecfd637b35b5 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 07:37:57 -0600 Subject: [PATCH 19/23] Add hsfload.h header --- include/game/hsfload.h | 12 ++++++++++++ src/game/hsfload.c | 14 +++++++------- 2 files changed, 19 insertions(+), 7 deletions(-) create mode 100644 include/game/hsfload.h diff --git a/include/game/hsfload.h b/include/game/hsfload.h new file mode 100644 index 00000000..b390f179 --- /dev/null +++ b/include/game/hsfload.h @@ -0,0 +1,12 @@ +#ifndef _HSFLOAD_H +#define _HSFLOAD_H + +#include "game/hsfformat.h" + +HsfData *LoadHSF(void *data); +void ClusterAdjustObject(HsfData *model, HsfData *src_model); +char *SetName(u32 *str_ofs); +char *MakeObjectName(char *name); +int CmpObjectName(char *name1, char *name2); + +#endif \ No newline at end of file diff --git a/src/game/hsfload.c b/src/game/hsfload.c index 65b23684..932a4503 100644 --- a/src/game/hsfload.c +++ b/src/game/hsfload.c @@ -1,4 +1,4 @@ -#include "game/hsfformat.h" +#include "game/hsfload.h" #include "string.h" #include "ctype.h" @@ -89,24 +89,24 @@ HsfData *LoadHSF(void *data) } -void ClusterAdjustObject(HsfData *src_model, HsfData *model) +void ClusterAdjustObject(HsfData *model, HsfData *src_model) { HsfCluster *cluster; s32 i; - if(!model) { + if(!src_model) { return; } - if(model->clusterCnt == 0) { + if(src_model->clusterCnt == 0) { return; } - cluster = model->cluster; + cluster = src_model->cluster; if(cluster->adjusted) { return; } cluster->adjusted = 1; - for(i=0; iclusterCnt; i++, cluster++) { + for(i=0; iclusterCnt; i++, cluster++) { char *name = cluster->targetName; - cluster->target = SearchObjectSetName(src_model, name); + cluster->target = SearchObjectSetName(model, name); } } From 894293c2f3d844fecfc898946d7fa8ded416809a Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 07:38:52 -0600 Subject: [PATCH 20/23] Fix Include Guards --- include/game/hsfformat.h | 4 ++-- include/game/hsfload.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 513ac699..7ddf65c0 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -1,5 +1,5 @@ -#ifndef _HSF_FORMAT_H -#define _HSF_FORMAT_H +#ifndef _GAME_HSFFORMAT_H +#define _GAME_HSFFORMAT_H #include "dolphin.h" diff --git a/include/game/hsfload.h b/include/game/hsfload.h index b390f179..9db51807 100644 --- a/include/game/hsfload.h +++ b/include/game/hsfload.h @@ -1,5 +1,5 @@ -#ifndef _HSFLOAD_H -#define _HSFLOAD_H +#ifndef _GAME_HSFLOAD_H +#define _GAME_HSFLOAD_H #include "game/hsfformat.h" From 2c8b0169ccfc76446716faafc0395ad5e583168e Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 09:29:08 -0600 Subject: [PATCH 21/23] Split first 4 board translation units --- config/GMPE01_00/splits.txt | 32 ++++++++++++++++++++++++++++++++ config/GMPE01_00/symbols.txt | 2 +- configure.py | 4 ++++ 3 files changed, 37 insertions(+), 1 deletion(-) diff --git a/config/GMPE01_00/splits.txt b/config/GMPE01_00/splits.txt index 59286405..17a7fe0a 100644 --- a/config/GMPE01_00/splits.txt +++ b/config/GMPE01_00/splits.txt @@ -316,6 +316,38 @@ game/sreset.c: .sdata start:0x801D3658 end:0x801D3670 .sbss start:0x801D3EB8 end:0x801D3ED0 +game/board/main.c: + .text start:0x8005B150 end:0x80061F44 + .rodata start:0x8011DD60 end:0x8011DD90 + .data start:0x80139798 end:0x80139898 + .bss start:0x8019D7E0 end:0x8019D968 + .sdata start:0x801D3670 end:0x801D3680 + .sbss start:0x801D3ED0 end:0x801D3F20 + .sdata2 start:0x801D5148 end:0x801D51F8 + +game/board/board.c: + .text start:0x80061F44 end:0x8006D248 + .rodata start:0x8011DD90 end:0x8011DE60 + .data start:0x80139898 end:0x80139AA0 + .bss start:0x8019D968 end:0x8019D998 + .sdata start:0x801D3680 end:0x801D36E0 + .sbss start:0x801D3F20 end:0x801D3F58 + .sdata2 start:0x801D51F8 end:0x801D5300 + +game/board/model.c: + .text start:0x8006D248 end:0x8006FD7C + .sbss start:0x801D3F58 end:0x801D3F68 + .sdata2 start:0x801D5300 end:0x801D5318 + +game/board/window.c: + .text start:0x8006FD7C end:0x800714F8 + .rodata start:0x8011DE60 end:0x8011DED0 + .data start:0x80139AA0 end:0x80139B00 + .bss start:0x8019D998 end:0x8019D9F8 + .sdata start:0x801D36E0 end:0x801D36F0 + .sbss start:0x801D3F68 end:0x801D3F98 + .sdata2 start:0x801D5318 end:0x801D5328 + dolphin/PPCArch.c: .text start:0x800B42F4 end:0x800B439C diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index f0fb8689..99cc3d00 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -6260,7 +6260,7 @@ lbl_801D3F04 = .sbss:0x801D3F04; // type:object size:0x4 data:4byte lbl_801D3F08 = .sbss:0x801D3F08; // type:object size:0x4 data:4byte lbl_801D3F0C = .sbss:0x801D3F0C; // type:object size:0x4 data:4byte lbl_801D3F10 = .sbss:0x801D3F10; // type:object size:0x4 data:4byte -rngSeed = .sbss:0x801D3F14; // type:object size:0x4 data:4byte +boardRandSeed = .sbss:0x801D3F14; // type:object size:0x4 scope:local data:4byte lbl_801D3F18 = .sbss:0x801D3F18; // type:object size:0x8 data:4byte lbl_801D3F20 = .sbss:0x801D3F20; // type:object size:0x4 data:4byte lbl_801D3F24 = .sbss:0x801D3F24; // type:object size:0x4 data:4byte diff --git a/configure.py b/configure.py index 8c1b85db..e95b7649 100755 --- a/configure.py +++ b/configure.py @@ -280,6 +280,10 @@ config.libs = [ Object(NonMatching, "game/flag.c"), Object(NonMatching, "game/saveload.c"), Object(NonMatching, "game/sreset.c"), + Object(NonMatching, "game/board/main.c"), + Object(NonMatching, "game/board/board.c"), + Object(NonMatching, "game/board/model.c"), + Object(NonMatching, "game/board/window.c"), ], }, DolphinLib( From 2e5917ef89f4aab2c2151cceca72d3b2b8c08c6d Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 11:25:43 -0600 Subject: [PATCH 22/23] Split Board Code More Split until 0x8007FB50 --- config/GMPE01_00/splits.txt | 38 ++++++++++++++++++++++++++++++++++++ config/GMPE01_00/symbols.txt | 22 ++++++++++----------- configure.py | 5 +++++ include/functions.h | 6 +++--- src/REL/w10Dll/w10Dll2.c | 6 +++--- 5 files changed, 60 insertions(+), 17 deletions(-) diff --git a/config/GMPE01_00/splits.txt b/config/GMPE01_00/splits.txt index 17a7fe0a..49a3522f 100644 --- a/config/GMPE01_00/splits.txt +++ b/config/GMPE01_00/splits.txt @@ -348,6 +348,44 @@ game/board/window.c: .sbss start:0x801D3F68 end:0x801D3F98 .sdata2 start:0x801D5318 end:0x801D5328 +game/board/com.c: + .text start:0x800714F8 end:0x800729A4 + .data start:0x80139B00 end:0x80139BC8 + .sdata start:0x801D36F0 end:0x801D36F8 + .sdata2 start:0x801D5328 end:0x801D5350 + +game/board/overhead.c: + .text start:0x800729A4 end:0x80073FF4 + .rodata start:0x8011DED0 end:0x8011DEF0 + .data start:0x80139BC8 end:0x80139CC8 + .bss start:0x8019D9F8 end:0x8019DA10 + .sdata start:0x801D36F8 end:0x801D3700 + .sbss start:0x801D3F98 end:0x801D3FB0 + .sdata2 start:0x801D5350 end:0x801D53C0 + +game/board/space.c: + .text start:0x80073FF4 end:0x80077AAC + .data start:0x80139CC8 end:0x80139D08 + .bss start:0x8019DA10 end:0x801A4A10 + .sdata start:0x801D3700 end:0x801D3708 + .sbss start:0x801D3FB0 end:0x801D3FE8 + .sdata2 start:0x801D53C0 end:0x801D5440 + +game/board/shop.c: + .text start:0x80077AAC end:0x8007A83C + .data start:0x80139D08 end:0x80139E88 + .sdata start:0x801D3708 end:0x801D3728 + .sbss start:0x801D3FE8 end:0x801D4008 + .sdata2 start:0x801D5440 end:0x801D5510 + +game/board/lottery.c: + .text start:0x8007A83C end:0x8007FB50 + .rodata start:0x8011DEF0 end:0x8011E020 + .data start:0x80139E88 end:0x8013A1F0 + .sdata start:0x801D3728 end:0x801D3748 + .sbss start:0x801D4008 end:0x801D4028 + .sdata2 start:0x801D5510 end:0x801D56A0 + dolphin/PPCArch.c: .text start:0x800B42F4 end:0x800B439C diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index 99cc3d00..e1048fb0 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -1294,13 +1294,13 @@ fn_8006FDA0 = .text:0x8006FDA0; // type:function size:0x34 fn_8006FDD4 = .text:0x8006FDD4; // type:function size:0x24 fn_8006FDF8 = .text:0x8006FDF8; // type:function size:0x6C fn_8006FE64 = .text:0x8006FE64; // type:function size:0x514 -BoardMessChoiceGet = .text:0x80070378; // type:function size:0xC +BoardWinChoiceGet = .text:0x80070378; // type:function size:0xC fn_80070384 = .text:0x80070384; // type:function size:0xC fn_80070390 = .text:0x80070390; // type:function size:0x1A0 -BoardMessCreate = .text:0x80070530; // type:function size:0x1A0 +BoardWinCreate = .text:0x80070530; // type:function size:0x1A0 fn_800706D0 = .text:0x800706D0; // type:function size:0x18 -BoardMessWait = .text:0x800706E8; // type:function size:0x50 -BoardMessKill = .text:0x80070738; // type:function size:0x38 +BoardWinWait = .text:0x800706E8; // type:function size:0x50 +BoardWinKill = .text:0x80070738; // type:function size:0x38 fn_80070770 = .text:0x80070770; // type:function size:0x48 fn_800707B8 = .text:0x800707B8; // type:function size:0x48 fn_80070800 = .text:0x80070800; // type:function size:0x1C @@ -1338,7 +1338,7 @@ fn_800713E8 = .text:0x800713E8; // type:function size:0x28 fn_80071410 = .text:0x80071410; // type:function size:0xE8 fn_800714F8 = .text:0x800714F8; // type:function size:0x100 fn_800715F8 = .text:0x800715F8; // type:function size:0x120 -CpuDecideItemPurchaseInner = .text:0x80071718; // type:function size:0x74 +BoardCOMGetItemWeight = .text:0x80071718; // type:function size:0x74 fn_8007178C = .text:0x8007178C; // type:function size:0xD0 fn_8007185C = .text:0x8007185C; // type:function size:0x6C fn_800718C8 = .text:0x800718C8; // type:function size:0x68 @@ -1375,7 +1375,7 @@ fn_80073FC4 = .text:0x80073FC4; // type:function size:0x30 fn_80073FF4 = .text:0x80073FF4; // type:function size:0x8 fn_80073FFC = .text:0x80073FFC; // type:function size:0x8 fn_80074004 = .text:0x80074004; // type:function size:0x8 -RunEvent = .text:0x8007400C; // type:function size:0x48 +BoardSpaceExecPassEvent = .text:0x8007400C; // type:function size:0x48 fn_80074054 = .text:0x80074054; // type:function size:0x60 fn_800740B4 = .text:0x800740B4; // type:function size:0x10 fn_800740C4 = .text:0x800740C4; // type:function size:0x44 @@ -1437,7 +1437,7 @@ fn_80079864 = .text:0x80079864; // type:function size:0xA0 fn_80079904 = .text:0x80079904; // type:function size:0x14C fn_80079A50 = .text:0x80079A50; // type:function size:0x1C8 fn_80079C18 = .text:0x80079C18; // type:function size:0x60 -CpuDecideItemPurchase = .text:0x80079C78; // type:function size:0x158 +COMGetShopItemSelect = .text:0x80079C78; // type:function size:0x158 scope:local fn_80079DD0 = .text:0x80079DD0; // type:function size:0x30 fn_80079E00 = .text:0x80079E00; // type:function size:0x188 fn_80079F88 = .text:0x80079F88; // type:function size:0xC @@ -5161,8 +5161,8 @@ lbl_80139A70 = .data:0x80139A70; // type:object size:0x30 lbl_80139AA0 = .data:0x80139AA0; // type:object size:0x24 lbl_80139AC4 = .data:0x80139AC4; // type:object size:0x24 lbl_80139AE8 = .data:0x80139AE8; // type:object size:0x18 -CharacterItemPreferences = .data:0x80139B00; // type:object size:0x60 -CPUItemUsageTimingFunctions = .data:0x80139B60; // type:object size:0x38 +COMItemWeightTbl = .data:0x80139B00; // type:object size:0x60 scope:local +COMItemUseCheckFuncTbl = .data:0x80139B60; // type:object size:0x38 scope:local lbl_80139B98 = .data:0x80139B98; // type:object size:0x30 lbl_80139BC8 = .data:0x80139BC8; // type:object size:0xB8 lbl_80139C80 = .data:0x80139C80; // type:object size:0x24 @@ -5171,7 +5171,7 @@ lbl_80139CC8 = .data:0x80139CC8; // type:object size:0xC lbl_80139CD4 = .data:0x80139CD4; // type:object size:0xC jumptable_80139CE0 = .data:0x80139CE0; // type:object size:0x28 scope:local lbl_80139D08 = .data:0x80139D08; // type:object size:0x24 -ItemPrices = .data:0x80139D2C; // type:object size:0x10 +ItemPriceTbl = .data:0x80139D2C; // type:object size:0x10 scope:local lbl_80139D3C = .data:0x80139D3C; // type:object size:0x6C lbl_80139DA8 = .data:0x80139DA8; // type:object size:0xB0 lbl_80139E58 = .data:0x80139E58; // type:object size:0x30 data:float @@ -5501,7 +5501,7 @@ lbl_8019D998 = .bss:0x8019D998; // type:object size:0x20 lbl_8019D9B8 = .bss:0x8019D9B8; // type:object size:0x40 lbl_8019D9F8 = .bss:0x8019D9F8; // type:object size:0xC data:float lbl_8019DA04 = .bss:0x8019DA04; // type:object size:0xC data:4byte -SpaceData = .bss:0x8019DA10; // type:object size:0x7000 data:float +SpaceData = .bss:0x8019DA10; // type:object size:0x7000 scope:local data:float lbl_801A4A10 = .bss:0x801A4A10; // type:object size:0x50 lbl_801A4A60 = .bss:0x801A4A60; // type:object size:0x14 data:4byte lbl_801A4A74 = .bss:0x801A4A74; // type:object size:0x1C diff --git a/configure.py b/configure.py index e95b7649..89c56295 100755 --- a/configure.py +++ b/configure.py @@ -284,6 +284,11 @@ config.libs = [ Object(NonMatching, "game/board/board.c"), Object(NonMatching, "game/board/model.c"), Object(NonMatching, "game/board/window.c"), + Object(NonMatching, "game/board/com.c"), + Object(NonMatching, "game/board/overhead.c"), + Object(NonMatching, "game/board/space.c"), + Object(NonMatching, "game/board/shop.c"), + Object(NonMatching, "game/board/lottery.c"), ], }, DolphinLib( diff --git a/include/functions.h b/include/functions.h index dd1db21e..8a43084f 100644 --- a/include/functions.h +++ b/include/functions.h @@ -53,9 +53,9 @@ void fn_8004D6F4(s16 arg); s32 _CheckFlag(u32 flag); -void BoardMessCreate(s16, s32, s32); -void BoardMessKill(void); -void BoardMessWait(void); +void BoardWinCreate(s16, s32, s32); +void BoardWinKill(void); +void BoardWinWait(void); s32 HuTHPFrameGet(void); diff --git a/src/REL/w10Dll/w10Dll2.c b/src/REL/w10Dll/w10Dll2.c index c217853e..72ceaee4 100644 --- a/src/REL/w10Dll/w10Dll2.c +++ b/src/REL/w10Dll/w10Dll2.c @@ -31,9 +31,9 @@ void fn_1_BA0(s32 arg0) { var_r31 = 6; break; } - BoardMessCreate(var_r31, arg0, -1); - BoardMessWait(); - BoardMessKill(); + BoardWinCreate(var_r31, arg0, -1); + BoardWinWait(); + BoardWinKill(); } void fn_1_C10(s16 arg0) { From 20ed8d70768a0e574744e7d1c8746ed9a8bcc2a9 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Tue, 5 Dec 2023 18:37:40 -0600 Subject: [PATCH 23/23] Split until items --- config/GMPE01_00/splits.txt | 76 +++++++++++++++++++++++++++++++++++- config/GMPE01_00/symbols.txt | 2 +- configure.py | 9 +++++ 3 files changed, 85 insertions(+), 2 deletions(-) diff --git a/config/GMPE01_00/splits.txt b/config/GMPE01_00/splits.txt index 49a3522f..e1122005 100644 --- a/config/GMPE01_00/splits.txt +++ b/config/GMPE01_00/splits.txt @@ -366,7 +366,7 @@ game/board/overhead.c: game/board/space.c: .text start:0x80073FF4 end:0x80077AAC .data start:0x80139CC8 end:0x80139D08 - .bss start:0x8019DA10 end:0x801A4A10 + .bss start:0x8019DA10 end:0x801A4A60 .sdata start:0x801D3700 end:0x801D3708 .sbss start:0x801D3FB0 end:0x801D3FE8 .sdata2 start:0x801D53C0 end:0x801D5440 @@ -374,6 +374,7 @@ game/board/space.c: game/board/shop.c: .text start:0x80077AAC end:0x8007A83C .data start:0x80139D08 end:0x80139E88 + .bss start:0x801A4A60 end:0x801A4A90 .sdata start:0x801D3708 end:0x801D3728 .sbss start:0x801D3FE8 end:0x801D4008 .sdata2 start:0x801D5440 end:0x801D5510 @@ -382,10 +383,83 @@ game/board/lottery.c: .text start:0x8007A83C end:0x8007FB50 .rodata start:0x8011DEF0 end:0x8011E020 .data start:0x80139E88 end:0x8013A1F0 + .bss start:0x801A4A90 end:0x801A4AC0 .sdata start:0x801D3728 end:0x801D3748 .sbss start:0x801D4008 end:0x801D4028 .sdata2 start:0x801D5510 end:0x801D56A0 +game/board/basic_space.c: + .text start:0x8007FB50 end:0x80080D54 + .data start:0x8013A1F0 end:0x8013A228 + .sdata2 start:0x801D56A0 end:0x801D5730 + +game/board/warp.c: + .text start:0x80080D54 end:0x800816CC + .rodata start:0x8011E020 end:0x8011E040 + .data start:0x8013A228 end:0x8013A248 + .bss start:0x801A4AC0 end:0x801A4AD0 + .sdata start:0x801D3748 end:0x801D3758 + .sbss start:0x801D4028 end:0x801D4040 + .sdata2 start:0x801D5730 end:0x801D5780 + +game/board/char_roulette.c: + .text start:0x800816CC end:0x80082C90 + .data start:0x8013A248 end:0x8013A2B0 + .sdata start:0x801D3758 end:0x801D3760 + .sbss start:0x801D4040 end:0x801D4060 + .sdata2 start:0x801D5780 end:0x801D5810 + +game/board/mushroom_space.c: + .text start:0x80082C90 end:0x80083EDC + .sdata start:0x801D3760 end:0x801D3770 + .sbss start:0x801D4060 end:0x801D4070 + .sdata2 start:0x801D5810 end:0x801D5898 + +game/board/star.c: + .text start:0x80083EDC end:0x80085CC8 + .rodata start:0x8011E040 end:0x8011E0B0 + .data start:0x8013A2B0 end:0x8013A368 + .bss start:0x801A4AD0 end:0x801A4AE0 + .sdata start:0x801D3770 end:0x801D3778 + .sbss start:0x801D4070 end:0x801D4088 + .sdata2 start:0x801D5898 end:0x801D5938 + +game/board/dice_roll.c: + .text start:0x80085CC8 end:0x8008831C + .rodata start:0x8011E0B0 end:0x8011E118 + .data start:0x8013A368 end:0x8013A408 + .bss start:0x801A4AE0 end:0x801A4AF0 + .sdata start:0x801D3778 end:0x801D3790 + .sbss start:0x801D4088 end:0x801D40A8 + .sdata2 start:0x801D5938 end:0x801D59E0 + +game/board/ui.c: + .text start:0x8008831C end:0x8008DF68 + .rodata start:0x8011E118 end:0x8011E200 + .data start:0x8013A408 end:0x8013A608 + .bss start:0x801A4AF0 end:0x801A4B80 + .sdata start:0x801D3790 end:0x801D3798 + .sbss start:0x801D40A8 end:0x801D40E0 + .sdata2 start:0x801D59E0 end:0x801D5AA0 + +game/board/hidden_block.c: + .text start:0x8008DF68 end:0x8008EE28 + .rodata start:0x8011E200 end:0x8011E220 + .data start:0x8013A608 end:0x8013A620 + .bss start:0x801A4B80 end:0x801A4BA8 + .sdata start:0x801D3798 end:0x801D37A0 + .sbss start:0x801D40E0 end:0x801D40F8 + .sdata2 start:0x801D5AA0 end:0x801D5AF8 + +game/board/item.c: + .text start:0x8008EE28 end:0x800975AC + .rodata start:0x8011E220 end:0x8011E238 + .data start:0x8013A620 end:0x8013AA10 + .bss start:0x801A4BA8 end:0x801A4BE8 + .sdata start:0x801D37A0 end:0x801D37B0 + .sbss start:0x801D40F8 end:0x801D4138 + .sdata2 start:0x801D5AF8 end:0x801D5D30 + dolphin/PPCArch.c: .text start:0x800B42F4 end:0x800B439C diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index e1048fb0..de746dd1 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -5192,7 +5192,7 @@ lbl_8013A248 = .data:0x8013A248; // type:object size:0x58 lbl_8013A2A0 = .data:0x8013A2A0; // type:object size:0x10 lbl_8013A2B0 = .data:0x8013A2B0; // type:object size:0x20 lbl_8013A2D0 = .data:0x8013A2D0; // type:object size:0x48 -lbl_8013A318 = .data:0x8013A318; // type:object size:0x50 +lbl_8013A318 = .data:0x8013A318; // type:object size:0x50 noreloc lbl_8013A368 = .data:0x8013A368; // type:object size:0xC data:4byte lbl_8013A374 = .data:0x8013A374; // type:object size:0xC data:4byte lbl_8013A380 = .data:0x8013A380; // type:object size:0xC diff --git a/configure.py b/configure.py index 89c56295..210cdc43 100755 --- a/configure.py +++ b/configure.py @@ -289,6 +289,15 @@ config.libs = [ Object(NonMatching, "game/board/space.c"), Object(NonMatching, "game/board/shop.c"), Object(NonMatching, "game/board/lottery.c"), + Object(NonMatching, "game/board/basic_space.c"), + Object(NonMatching, "game/board/warp.c"), + Object(NonMatching, "game/board/char_roulette.c"), + Object(NonMatching, "game/board/mushroom_space.c"), + Object(NonMatching, "game/board/star.c"), + Object(NonMatching, "game/board/dice_roll.c"), + Object(NonMatching, "game/board/ui.c"), + Object(NonMatching, "game/board/hidden_block.c"), + Object(NonMatching, "game/board/item.c"), ], }, DolphinLib(