From 5d9586c9cdc34d5dece6229f800a716f58975934 Mon Sep 17 00:00:00 2001 From: gamemasterplc Date: Sun, 3 Dec 2023 22:12:31 -0600 Subject: [PATCH] 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