kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

More byteswaps in hsfload.c

Browse source
This commit is contained in:
dbalatoni13 2025-04-10 16:39:36 +02:00
parent f31f250258
commit 319eb2076c
13 changed files with 499 additions and 190 deletions
Download patch file Download diff file Expand all files Collapse all files

3
include/game/hsfload.h
View file

@ -8,5 +8,8 @@ void ClusterAdjustObject(HsfData *model, HsfData *src_model);
char *SetName(u32 *str_ofs);
char *MakeObjectName(char *name);
s32 CmpObjectName(char *name1, char *name2);
#ifdef TARGET_PC
void KillHSF(HsfData *data);
#endif
#endif

6
include/game/hsfmotion.h
View file

@ -10,9 +10,9 @@
typedef struct motion_data {
s16 unk_00;
s16 unk_02;
HsfData *unk_04;
s16 attr;
s16 modelId;
HsfData *hsfData;
} MotionData;
typedef struct {

87
include/port/byteswap.h
View file

@ -132,19 +132,89 @@ typedef struct HsfCenv32b {
u32 copyCount;
} HsfCenv32b;
typedef struct HsfObjectData32b {
u32 parent;
u32 childrenCount;
u32 children;
HsfTransform base;
HsfTransform curr;
union {
struct {
HsfVector3f min;
HsfVector3f max;
float baseMorph;
float morphWeight[33];
} mesh;
struct hsf_object *replica;
};
u32 face;
u32 vertex;
u32 normal;
u32 color;
u32 st;
u32 material;
u32 attribute;
u8 unk120[2];
u8 shapeType;
u8 unk123;
u32 vertexShapeCnt;
u32 vertexShape;
u32 clusterCnt;
u32 cluster;
u32 cenvCnt;
u32 cenv;
u32 file[2];
} HsfObjectData32b;
typedef struct HsfObject32b {
u32 name;
u32 type;
u32 constData;
u32 flags;
// TODO PC
union {
HsfObjectData data;
HsfCamera camera;
HsfLight light;
};
HsfObjectData32b data;
} HsfObject32b;
typedef struct HsfTrack32b {
u8 type;
u8 start;
union {
u16 target;
s16 target_s16;
};
union {
s32 unk04;
struct {
union {
s16 param;
u16 param_u16;
};
union {
u16 channel;
s16 channel_s16;
};
};
};
u16 curveType;
u16 numKeyframes;
union {
float value;
u32 data;
};
} HsfTrack32b;
typedef struct HsfMotion32b {
u32 name;
s32 numTracks;
u32 track;
float len;
} HsfMotion32b;
typedef struct HsfBitmapKey32b {
float time;
u32 data;
} HsfBitmapKey32b;
void byteswap_u16(u16 *src);
void byteswap_s16(s16 *src);
void byteswap_u32(u32 *src);
@ -172,9 +242,12 @@ void byteswap_hsfbitmap(HsfBitmap32b *src, HsfBitmap *dest);
void byteswap_hsfmapattr(HsfMapAttr32b *src, HsfMapAttr *dest);
void byteswap_hsfskeleton(HsfSkeleton32b *src, HsfSkeleton *dest);
void byteswap_hsfshape(HsfShape32b *src, HsfShape *dest);
void byteswap_hsfcenvsingle(HsfCenvSingle *src);
void byteswap_hsfcenv_single(HsfCenvSingle *src);
void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest);
void byteswap_hsfobject(HsfObject32b *src, HsfObject *dest);
void byteswap_hsfbitmapkey(HsfBitmapKey32b *src, HsfBitmapKey *dest);
void byteswap_hsftrack(HsfTrack32b *src, HsfTrack *dest);
void byteswap_hsfmotion(HsfMotion32b *src, HsfMotion *dest);
#ifdef __cplusplus
}

2
src/REL/E3setupDLL/main.c
View file

@ -300,7 +300,7 @@ float MotionMaxTimeGet(s16 arg0)
HsfMotion *temp_r30;
s16 temp_r29;
temp_r30 = temp_r31->unk_04->motion;
temp_r30 = temp_r31->hsfData->motion;
temp_r29 = temp_r30->len;
return temp_r29;
}

2
src/REL/bootDll/main.c
View file

@ -565,9 +565,9 @@ void ObjectSetup(void)
s16 sprite;
AnimData *sprite_data;
s16 i;
titleMdlId[0] = model = Hu3DModelCreateFile(TITLE_CHAR_HSF);
#ifdef __MWERKS__
// TODO PC
titleMdlId[0] = model = Hu3DModelCreateFile(TITLE_CHAR_HSF);
Hu3DModelAttrSet(model, HU3D_ATTR_DISPOFF);
Hu3DModelAttrSet(model, HU3D_MOTATTR_LOOP);
titleMdlId[1] = model = Hu3DModelCreateFile(TITLE_CUBE_HSF);

2
src/REL/m409Dll/player.c
View file

@ -1263,7 +1263,7 @@ f32 fn_1_BF38(s16 arg0)
f32 length;
motionData = &Hu3DMotion[arg0];
hsfMotionData = motionData->unk_04->motion;
hsfMotionData = motionData->hsfData->motion;
length = hsfMotionData->len;
return length;
}

4
src/game/ClusterExec.c
View file

@ -117,7 +117,7 @@ void ClusterProc(ModelData *arg0)
temp_r24 = arg0->unk_10[i];
if (temp_r24 != -1) {
temp_r22 = &Hu3DMotion[temp_r24];
temp_r27 = temp_r22->unk_04;
temp_r27 = temp_r22->hsfData;
temp_r23 = arg0->hsfData;
var_r29 = temp_r27->cluster;
for (j = 0; j < temp_r27->clusterCnt; j++, var_r29++) {
@ -159,7 +159,7 @@ void ClusterMotionExec(ModelData *arg0)
if (arg0->unk_10[i] != -1) {
var_r20 = arg0->unk_10[i];
var_r23 = &Hu3DMotion[var_r20];
temp_r28 = var_r23->unk_04;
temp_r28 = var_r23->hsfData;
temp_r27 = temp_r28->motion;
var_r31 = temp_r27->track;
temp_f31 = arg0->unk_A4[i];

2
src/game/board/model.c
View file

@ -747,7 +747,7 @@ float BoardModelMotionShapeMaxTimeGet(s16 model)
return 0;
}
motion = &Hu3DMotion[hsf_model->unk_0E];
motion_hsf = motion->unk_04->motion;
motion_hsf = motion->hsfData->motion;
return motion_hsf->len;
}
}

2
src/game/hsfex.c
View file

@ -59,7 +59,7 @@ void CamMotionEx(s16 arg0, s16 arg1, Vec *arg2, Vec *arg3, Vec *arg4, float arg5
temp_r23 = &Hu3DData[arg0];
temp_r19 = &Hu3DMotion[temp_r23->unk_08];
temp_r22 = temp_r23->hsfData;
temp_r18 = temp_r19->unk_04;
temp_r18 = temp_r19->hsfData;
temp_r26 = temp_r18->motion;
for (var_r25 = 0; var_r25 < HU3D_CAM_MAX; var_r25++) {
if (arg1 & (1 << var_r25)) {

199
src/game/hsfload.c
View file

@ -143,15 +143,18 @@ static void FileLoad(void *data)
StringTable = (char *)((uintptr_t)fileptr+head.string.ofs);
ClusterTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfCluster) * head.cluster.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.cluster.count; i++) {
byteswap_hsfcluster(&((HsfCluster32b *)((uintptr_t)fileptr + head.cluster.ofs))[i], &ClusterTop[i]);
HsfCluster32b *file_cluster_real = (HsfCluster32b *)((uintptr_t)fileptr + head.cluster.ofs);
byteswap_hsfcluster(&file_cluster_real[i], &ClusterTop[i]);
}
AttributeTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfAttribute) * head.attribute.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.attribute.count; i++) {
byteswap_hsfattribute(&((HsfAttribute32b *)((uintptr_t)fileptr + head.attribute.ofs))[i], &AttributeTop[i]);
HsfAttribute32b *file_attribute_real = (HsfAttribute32b *)((uintptr_t)fileptr + head.attribute.ofs);
byteswap_hsfattribute(&file_attribute_real[i], &AttributeTop[i]);
}
MaterialTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMaterial) * head.material.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.material.count; i++) {
byteswap_hsfmaterial(&((HsfMaterial32b *)((uintptr_t)fileptr + head.material.ofs))[i], &MaterialTop[i]);
HsfMaterial32b *file_material_real = (HsfMaterial32b *)((uintptr_t)fileptr + head.material.ofs);
byteswap_hsfmaterial(&file_material_real[i], &MaterialTop[i]);
}
#else
NSymIndex = (void **)((uintptr_t)fileptr+head.symbol.ofs);
@ -273,10 +276,7 @@ static void MaterialLoad(void)
rgba[i].b = new_mat->litColor[2];
rgba[i].a = 255;
for(j=0; j<new_mat->numAttrs; j++) {
#ifdef __MWERKS__
// TODO PC
new_mat->attrs[j] = new_mat->attrs[j];
#endif
}
}
}
@ -341,9 +341,10 @@ static void ColorLoad(void)
if(head.color.count) {
#ifdef TARGET_PC
HsfBuffer32b * file_color_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.color.ofs);
temp_color = file_color = ColorTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.color.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.color.count; i++) {
byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.color.ofs))[i], &file_color[i]);
byteswap_hsfbuffer(&file_color_real[i], &file_color[i]);
}
#else
temp_color = file_color = (HsfBuffer *)((u32)fileptr+head.color.ofs);
@ -354,7 +355,7 @@ static void ColorLoad(void)
Model.color = new_color;
Model.colorCnt = head.color.count;
#ifdef TARGET_PC
data = (u16 *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.color.ofs))[head.color.count];
data = (u16 *)&file_color_real[head.color.count];
#else
file_color = (HsfBuffer *)((u32)fileptr+head.color.ofs);
data = &file_color[head.color.count];
@ -378,9 +379,10 @@ static void VertexLoad(void)
if(head.vertex.count) {
#ifdef TARGET_PC
HsfBuffer32b *file_vertex_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.vertex.ofs);
vtxtop = file_vertex = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.vertex.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.vertex.count; i++) {
byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.vertex.ofs))[i], &file_vertex[i]);
byteswap_hsfbuffer(&file_vertex_real[i], &file_vertex[i]);
}
#else
vtxtop = file_vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs);
@ -395,7 +397,7 @@ static void VertexLoad(void)
Model.vertex = new_vertex;
Model.vertexCnt = head.vertex.count;
#ifdef TARGET_PC
VertexDataTop = data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.vertex.ofs))[head.vertex.count];
VertexDataTop = data = (void *)&file_vertex_real[head.vertex.count];
#else
file_vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs);
VertexDataTop = data = (void *)&file_vertex[head.vertex.count];
@ -431,9 +433,10 @@ static void NormalLoad(void)
if(head.normal.count) {
s32 cenv_count = head.cenv.count;
#ifdef TARGET_PC
HsfBuffer32b *file_normal_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.normal.ofs);
temp_normal = file_normal = NormalTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.normal.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.normal.count; i++) {
byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.normal.ofs))[i], &file_normal[i]);
byteswap_hsfbuffer(&file_normal_real[i], &file_normal[i]);
}
#else
temp_normal = file_normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs);
@ -443,7 +446,7 @@ static void NormalLoad(void)
Model.normal = new_normal;
Model.normalCnt = head.normal.count;
#ifdef TARGET_PC
VertexDataTop = data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.normal.ofs))[head.normal.count];
VertexDataTop = data = (void *)&file_normal_real[head.normal.count];
#else
file_normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs);
NormalDataTop = data = (void *)&file_normal[head.normal.count];
@ -469,9 +472,10 @@ static void STLoad(void)
if(head.st.count) {
#ifdef TARGET_PC
HsfBuffer32b *file_st_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.st.ofs);
temp_st = file_st = StTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.st.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.st.count; i++) {
byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.st.ofs))[i], &file_st[i]);
byteswap_hsfbuffer(&file_st_real[i], &file_st[i]);
}
#else
temp_st = file_st = (HsfBuffer *)((u32)fileptr+head.st.ofs);
@ -486,7 +490,7 @@ static void STLoad(void)
Model.st = new_st;
Model.stCnt = head.st.count;
#ifdef TARGET_PC
data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.st.ofs))[head.st.count];
data = (void *)&file_st_real[head.st.count];
#else
file_st = (HsfBuffer *)((u32)fileptr+head.st.ofs);
data = (void *)&file_st[head.st.count];
@ -523,9 +527,10 @@ static void FaceLoad(void)
if(head.face.count) {
#ifdef TARGET_PC
HsfBuffer32b *file_face_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.face.ofs);
temp_face = file_face = FaceTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.face.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.face.count; i++) {
byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.face.ofs))[i], &file_face[i]);
byteswap_hsfbuffer(&file_face[i], &file_face[i]);
}
#else
temp_face = file_face = (HsfBuffer *)((u32)fileptr+head.face.ofs);
@ -535,7 +540,7 @@ static void FaceLoad(void)
Model.face = new_face;
Model.faceCnt = head.face.count;
#ifdef TARGET_PC
data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.face.ofs))[head.face.count];
data = (void *)&file_face_real[head.face.count];
#else
file_face = (HsfBuffer *)((u32)fileptr+head.face.ofs);
data = (HsfFace *)&file_face[head.face.count];
@ -559,6 +564,7 @@ static void FaceLoad(void)
#ifdef TARGET_PC
{
s32 k;
byteswap_u32(&new_face_strip->strip.count);
for (k = 0; k < new_face_strip->strip.count; k++) {
byteswap_s16(&new_face_strip->strip.data[k]);
}
@ -592,9 +598,9 @@ static void DispObject(HsfObject *parent, HsfObject *object)
data = &object->data;
new_object = temp_object = object;
new_object->data.childrenCount = data->childrenCount;
new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children];
new_object->data.children = (HsfObject **)&NSymIndex[(uintptr_t)data->children];
for(i=0; i<new_object->data.childrenCount; i++) {
child_obj = &objtop[(u32)new_object->data.children[i]];
child_obj = &objtop[(uintptr_t)new_object->data.children[i]];
new_object->data.children[i] = child_obj;
}
new_object->data.parent = parent;
@ -607,14 +613,14 @@ static void DispObject(HsfObject *parent, HsfObject *object)
new_object->data.st = SearchStPtr((s32)data->st);
new_object->data.color = SearchColorPtr((s32)data->color);
new_object->data.face = SearchFacePtr((s32)data->face);
new_object->data.vertexShape = (HsfBuffer **)&NSymIndex[(u32)data->vertexShape];
new_object->data.vertexShape = (HsfBuffer **)&NSymIndex[(uintptr_t)data->vertexShape];
for(i=0; i<new_object->data.vertexShapeCnt; i++) {
temp.shape = &vtxtop[(u32)new_object->data.vertexShape[i]];
temp.shape = &vtxtop[(uintptr_t)new_object->data.vertexShape[i]];
new_object->data.vertexShape[i] = temp.shape;
}
new_object->data.cluster = (HsfCluster **)&NSymIndex[(u32)data->cluster];
new_object->data.cluster = (HsfCluster **)&NSymIndex[(uintptr_t)data->cluster];
for(i=0; i<new_object->data.clusterCnt; i++) {
temp.cluster = &ClusterTop[(u32)new_object->data.cluster[i]];
temp.cluster = &ClusterTop[(uintptr_t)new_object->data.cluster[i]];
new_object->data.cluster[i] = temp.cluster;
}
new_object->data.cenv = SearchCenvPtr((s32)data->cenv);
@ -624,8 +630,8 @@ static void DispObject(HsfObject *parent, HsfObject *object)
} else {
new_object->data.attribute = NULL;
}
new_object->data.file[0] = (void *)((uintptr_t)fileptr+(u32)data->file[0]);
new_object->data.file[1] = (void *)((uintptr_t)fileptr+(u32)data->file[1]);
new_object->data.file[0] = (void *)((uintptr_t)fileptr + (uintptr_t)data->file[0]);
new_object->data.file[1] = (void *)((uintptr_t)fileptr + (uintptr_t)data->file[1]);
new_object->data.base.pos.x = data->base.pos.x;
new_object->data.base.pos.y = data->base.pos.y;
new_object->data.base.pos.z = data->base.pos.z;
@ -655,9 +661,9 @@ static void DispObject(HsfObject *parent, HsfObject *object)
new_object = temp_object = object;
new_object->data.parent = parent;
new_object->data.childrenCount = data->childrenCount;
new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children];
new_object->data.children = (HsfObject **)&NSymIndex[(uintptr_t)data->children];
for(i=0; i<new_object->data.childrenCount; i++) {
child_obj = &objtop[(u32)new_object->data.children[i]];
child_obj = &objtop[(uintptr_t)new_object->data.children[i]];
new_object->data.children[i] = child_obj;
}
if(Model.root == NULL) {
@ -677,15 +683,15 @@ static void DispObject(HsfObject *parent, HsfObject *object)
new_object = temp_object = object;
new_object->data.parent = parent;
new_object->data.childrenCount = data->childrenCount;
new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children];
new_object->data.children = (HsfObject **)&NSymIndex[(uintptr_t)data->children];
for(i=0; i<new_object->data.childrenCount; i++) {
child_obj = &objtop[(u32)new_object->data.children[i]];
child_obj = &objtop[(uintptr_t)new_object->data.children[i]];
new_object->data.children[i] = child_obj;
}
if(Model.root == NULL) {
Model.root = temp_object;
}
new_object->data.replica = &objtop[(u32)new_object->data.replica];
new_object->data.replica = &objtop[(uintptr_t)new_object->data.replica];
for(i=0; i<data->childrenCount; i++) {
DispObject(new_object, new_object->data.children[i]);
}
@ -821,9 +827,10 @@ static void ObjectLoad(void)
if(head.object.count) {
#ifdef TARGET_PC
HsfObject32b *file_object_real = (HsfObject32b *)((uintptr_t)fileptr + head.object.ofs);
objtop = object = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfObject) * head.object.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.object.count; i++) {
byteswap_hsfobject(&((HsfObject32b *)((uintptr_t)fileptr + head.object.ofs))[i], &objtop[i]);
byteswap_hsfobject(&file_object_real[i], &objtop[i]);
}
#else
objtop = object = (HsfObject *)((u32)fileptr+head.object.ofs);
@ -866,11 +873,12 @@ static void CenvLoad(void)
if(head.cenv.count) {
#ifdef TARGET_PC
HsfCenv32b *file_cenv_real = (HsfCenv32b *)((uintptr_t)fileptr + head.cenv.ofs);
cenv_file = CenvTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfCenv) * head.cenv.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.cenv.count; i++) {
byteswap_hsfcenv(&((HsfCenv32b *)((uintptr_t)fileptr + head.cenv.ofs))[i], &cenv_file[i]);
byteswap_hsfcenv(&file_cenv_real[i], &cenv_file[i]);
}
data_base = &((HsfCenv *)((uintptr_t)fileptr + head.cenv.ofs))[head.cenv.count];
data_base = &file_cenv_real[head.cenv.count];
#else
cenv_file = (HsfCenv *)((u32)fileptr+head.cenv.ofs);
data_base = &cenv_file[head.cenv.count];
@ -892,8 +900,8 @@ static void CenvLoad(void)
weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].dualCount * sizeof(HsfCenvDual)));
weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].multiCount * sizeof(HsfCenvMulti)));
#ifdef TARGET_PC
byteswap_hsfcenvsingle(cenv_new[i].singleData);
// TODO pc malloc dual, multi etc and byteswap them
byteswap_hsfcenv_single(cenv_new[i].singleData);
// TODO PC malloc dual, multi etc and byteswap them
#endif
}
for(i=0; i<head.cenv.count; i++) {
@ -944,9 +952,10 @@ static void SkeletonLoad(void)
if(head.skeleton.count) {
#ifdef TARGET_PC
HsfSkeleton32b *file_skeleton_real = (HsfSkeleton32b *)((uintptr_t)fileptr + head.skeleton.ofs);
skeleton_new = skeleton_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfSkeleton) * head.skeleton.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.skeleton.count; i++) {
byteswap_hsfskeleton(&((HsfSkeleton32b *)((uintptr_t)fileptr + head.skeleton.ofs))[i], &skeleton_file[i]);
byteswap_hsfskeleton(&file_skeleton_real[i], &skeleton_file[i]);
}
#else
skeleton_new = skeleton_file = (HsfSkeleton *)((u32)fileptr+head.skeleton.ofs);
@ -978,9 +987,10 @@ static void PartLoad(void)
if(head.part.count) {
#ifdef TARGET_PC
HsfPart32b *file_part_real = (HsfPart32b *)((uintptr_t)fileptr + head.part.ofs);
part_new = part_file = PartTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfPart) * head.part.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.part.count; i++) {
byteswap_hsfpart(&((HsfPart32b *)((uintptr_t)fileptr + head.part.ofs))[i], &part_file[i]);
byteswap_hsfpart(&file_part_real[i], &part_file[i]);
}
#else
part_new = part_file = (HsfPart *)((u32)fileptr+head.part.ofs);
@ -988,7 +998,7 @@ static void PartLoad(void)
Model.partCnt = head.part.count;
Model.part = part_file;
#ifdef TARGET_PC
data = (u16 *)&((HsfPart32b *)((uintptr_t)fileptr + head.part.ofs))[head.part.count];
data = (u16 *)&file_part_real[head.part.count];
#else
data = (u16 *)&part_file[head.part.count];
#endif
@ -1049,9 +1059,10 @@ static void ShapeLoad(void)
if(head.shape.count) {
#ifdef TARGET_PC
HsfShape32b *file_shape_real = (HsfShape32b *)((uintptr_t)fileptr + head.shape.ofs);
shape_new = shape_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfShape) * head.shape.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.shape.count; i++) {
byteswap_hsfshape(&((HsfShape32b *)((uintptr_t)fileptr + head.shape.ofs))[i], &shape_file[i]);
byteswap_hsfshape(&file_shape_real[i], &shape_file[i]);
}
#else
shape_new = shape_file = (HsfShape *)((u32)fileptr+head.shape.ofs);
@ -1085,9 +1096,10 @@ static void MapAttrLoad(void)
if(head.mapAttr.count) {
#ifdef TARGET_PC
HsfMapAttr32b *file_mapattr_real = (HsfMapAttr32b *)((uintptr_t)fileptr + head.mapAttr.ofs);
mapattr_file = mapattr_base = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMapAttr) * head.mapAttr.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.mapAttr.count; i++) {
byteswap_hsfmapattr(&((HsfMapAttr32b *)((uintptr_t)fileptr + head.mapAttr.ofs))[i], &mapattr_base[i]);
byteswap_hsfmapattr(&file_mapattr_real[i], &mapattr_base[i]);
}
#else
mapattr_file = mapattr_base = (HsfMapAttr *)((u32)fileptr+head.mapAttr.ofs);
@ -1096,7 +1108,7 @@ static void MapAttrLoad(void)
Model.mapAttrCnt = head.mapAttr.count;
Model.mapAttr = mapattr_base;
#ifdef TARGET_PC
data = (u16 *)&((HsfPart32b *)((uintptr_t)fileptr + head.part.ofs))[head.part.count];
data = (u16 *)&file_mapattr_real[head.part.count];
#else
data = (u16 *)&mapattr_base[head.mapAttr.count];
#endif
@ -1117,9 +1129,10 @@ static void BitmapLoad(void)
if(head.bitmap.count) {
#ifdef TARGET_PC
HsfBitmap32b *file_bitmap_real = (HsfBitmap32b *)((uintptr_t)fileptr + head.bitmap.ofs);
bitmap_temp = bitmap_file = BitmapTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBitmap) * head.bitmap.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.bitmap.count; i++) {
byteswap_hsfbitmap(&((HsfBitmap32b *)((uintptr_t)fileptr + head.bitmap.ofs))[i], &bitmap_file[i]);
byteswap_hsfbitmap(&file_bitmap_real[i], &bitmap_file[i]);
}
#else
bitmap_temp = bitmap_file = (HsfBitmap *)((u32)fileptr+head.bitmap.ofs);
@ -1130,7 +1143,7 @@ static void BitmapLoad(void)
Model.bitmap = bitmap_file;
Model.bitmapCnt = head.bitmap.count;
#ifdef TARGET_PC
data = (void *)&((HsfBitmap32b *)((uintptr_t)fileptr + head.st.ofs))[head.st.count];
data = (void *)&file_bitmap_real[head.st.count];
#else
bitmap_file = (HsfBitmap *)((u32)fileptr+head.bitmap.ofs);
data = &bitmap_file[head.bitmap.count];
@ -1165,9 +1178,10 @@ static void PaletteLoad(void)
if(head.palette.count) {
#ifdef TARGET_PC
HsfPalette32b *file_palette_real = (HsfPalette32b *)((uintptr_t)fileptr + head.palette.ofs);
palette_temp = palette_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfPalette) * head.palette.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.palette.count; i++) {
byteswap_hsfpalette(&((HsfPalette32b *)((uintptr_t)fileptr + head.palette.ofs))[i], &palette_file[i]);
byteswap_hsfpalette(&file_palette_real[i], &palette_file[i]);
}
#else
palette_temp = palette_file = (HsfPalette *)((u32)fileptr+head.palette.ofs);
@ -1180,7 +1194,7 @@ static void PaletteLoad(void)
Model.paletteCnt = head.palette.count;
palette_new = palette_temp;
#ifdef TARGET_PC
data_base = (u16 *)&((HsfPalette32b *)((uintptr_t)fileptr + head.palette.ofs))[head.palette.count];
data_base = (u16 *)&file_palette_real[head.palette.count];
#else
palette_file = (HsfPalette *)((u32)fileptr+head.palette.ofs);
data_base = (u16 *)&palette_file[head.palette.count];
@ -1342,21 +1356,21 @@ static inline void MotionLoadTransform(HsfTrack *track, void *data)
switch(track->curveType) {
case HSF_CURVE_STEP:
{
step_data = (float *)((u32)data+(u32)track->data);
step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = step_data;
}
break;
case HSF_CURVE_LINEAR:
{
linear_data = (float *)((u32)data+(u32)track->data);
linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = linear_data;
}
break;
case HSF_CURVE_BEZIER:
{
bezier_data = (float *)((u32)data+(u32)track->data);
bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = bezier_data;
}
break;
@ -1387,21 +1401,21 @@ static inline void MotionLoadCluster(HsfTrack *track, void *data)
switch(track->curveType) {
case HSF_CURVE_STEP:
{
step_data = (float *)((u32)data+(u32)track->data);
step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = step_data;
}
break;
case HSF_CURVE_LINEAR:
{
linear_data = (float *)((u32)data+(u32)track->data);
linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = linear_data;
}
break;
case HSF_CURVE_BEZIER:
{
bezier_data = (float *)((u32)data+(u32)track->data);
bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = bezier_data;
}
break;
@ -1432,21 +1446,21 @@ static inline void MotionLoadClusterWeight(HsfTrack *track, void *data)
switch(track->curveType) {
case HSF_CURVE_STEP:
{
step_data = (float *)((u32)data+(u32)track->data);
step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = step_data;
}
break;
case HSF_CURVE_LINEAR:
{
linear_data = (float *)((u32)data+(u32)track->data);
linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = linear_data;
}
break;
case HSF_CURVE_BEZIER:
{
bezier_data = (float *)((u32)data+(u32)track->data);
bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = bezier_data;
}
break;
@ -1468,21 +1482,21 @@ static inline void MotionLoadMaterial(HsfTrack *track, void *data)
switch(track->curveType) {
case HSF_CURVE_STEP:
{
step_data = (float *)((u32)data+(u32)track->data);
step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = step_data;
}
break;
case HSF_CURVE_LINEAR:
{
linear_data = (float *)((u32)data+(u32)track->data);
linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = linear_data;
}
break;
case HSF_CURVE_BEZIER:
{
bezier_data = (float *)((u32)data+(u32)track->data);
bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = bezier_data;
}
break;
@ -1515,30 +1529,38 @@ static inline void MotionLoadAttribute(HsfTrack *track, void *data)
switch(track->curveType) {
case HSF_CURVE_STEP:
{
step_data = (float *)((u32)data+(u32)track->data);
step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = step_data;
}
break;
case HSF_CURVE_LINEAR:
{
linear_data = (float *)((u32)data+(u32)track->data);
linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = linear_data;
}
break;
case HSF_CURVE_BEZIER:
{
bezier_data = (float *)((u32)data+(u32)track->data);
bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = bezier_data;
}
break;
case HSF_CURVE_BITMAP:
{
new_frame = file_frame = (HsfBitmapKey *)((u32)data+(u32)track->data);
#ifdef TARGET_PC
HsfBitmapKey32b *file_frame_real = (HsfBitmapKey32b *)((uintptr_t)data + (uintptr_t)track->data);
new_frame = file_frame = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBitmapKey) * track->numKeyframes, MEMORY_DEFAULT_NUM);
#else
new_frame = file_frame = (HsfBitmapKey *)((uintptr_t)data + (uintptr_t)track->data);
out_track->data = file_frame;
#endif
for(i=0; i<out_track->numKeyframes; i++, file_frame++, new_frame++) {
#ifdef TARGET_PC
byteswap_hsfbitmapkey(&file_frame_real[i], new_frame);
#endif
new_frame->data = SearchBitmapPtr((s32)file_frame->data);
}
}
@ -1560,12 +1582,31 @@ static void MotionLoad(void)
MotionOnly = FALSE;
MotionModel = NULL;
if(head.motion.count) {
#ifdef TARGET_PC
HsfMotion32b *file_motion_real = (HsfMotion32b *)((uintptr_t)fileptr + head.motion.ofs);
temp_motion = file_motion = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMotion) * head.motion.count, MEMORY_DEFAULT_NUM);
for (i = 0; i < head.motion.count; i++) {
byteswap_hsfmotion(&file_motion_real[i], &file_motion[i]);
}
#else
temp_motion = file_motion = (HsfMotion *)((uintptr_t)fileptr+head.motion.ofs);
#endif
new_motion = temp_motion;
Model.motion = new_motion;
Model.motionCnt = file_motion->numTracks;
#ifdef TARGET_PC
{
HsfTrack32b *track_base_real = (HsfTrack32b *)&file_motion_real[head.motion.count];
track_base = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfTrack) * file_motion->numTracks, MEMORY_DEFAULT_NUM);
track_data = &track_base_real[file_motion->numTracks];
for (i = 0; i < file_motion->numTracks; i++) {
byteswap_hsftrack(&track_base_real[i], &track_base[i]);
}
}
#else
track_base = (HsfTrack *)&file_motion[head.motion.count];
track_data = &track_base[file_motion->numTracks];
#endif
new_motion->track = track_base;
for(i=0; i<(s32)file_motion->numTracks; i++) {
switch(track_base[i].type) {
@ -1793,3 +1834,41 @@ static char *GetMotionString(u16 *str_ofs)
char *ret = &StringTable[*str_ofs];
return ret;
}
#ifdef TARGET_PC
void KillHSF(HsfData *data)
{
s32 i, j;
HuMemDirectFree(data->attribute);
HuMemDirectFree(data->bitmap);
HuMemDirectFree(data->cenv);
HuMemDirectFree(data->skeleton);
HuMemDirectFree(data->face);
HuMemDirectFree(data->material);
for (i = 0; i < data->motionCnt; i++) {
HsfMotion *motion = &data->motion[i];
for (j = 0; j < motion->numTracks; j++) {
HsfTrack *track = data->motion[i].track;
if (track->type == HSF_TRACK_ATTRIBUTE && track->curveType == HSF_CURVE_BITMAP) {
// in this case we needed to allocate space for HsfBitmapKey structs
HuMemDirectFree(track->data);
}
}
HuMemDirectFree(motion->track);
}
HuMemDirectFree(data->motion);
HuMemDirectFree(data->normal);
HuMemDirectFree(data->object);
HuMemDirectFree(data->matrix);
HuMemDirectFree(data->palette);
HuMemDirectFree(data->st);
HuMemDirectFree(data->vertex);
HuMemDirectFree(data->cenv);
HuMemDirectFree(data->cluster);
HuMemDirectFree(data->part);
HuMemDirectFree(data->shape);
HuMemDirectFree(data->mapAttr);
HuMemDirectFree(data->symbol);
// TODO PC free embedded data
}
#endif

12
src/game/hsfman.c
View file

@ -453,7 +453,7 @@ s16 Hu3DModelLink(s16 arg0) {
for (i = 0; i < 4; i++) {
var_r31->unk_10[i] = temp_r30->unk_10[i];
if (var_r31->unk_10[i] != -1) {
ClusterAdjustObject(var_r31->hsfData, Hu3DMotion[var_r31->unk_10[i]].unk_04);
ClusterAdjustObject(var_r31->hsfData, Hu3DMotion[var_r31->unk_10[i]].hsfData);
var_r31->attr |= HU3D_ATTR_CLUSTER_ON;
}
}
@ -564,6 +564,9 @@ void Hu3DModelKill(s16 arg0) {
}
Hu3DAnimModelKill(arg0);
if (temp_r31->unk_24 != -1) {
#ifdef TARGET_PC
KillHSF(temp_r31->hsfData);
#endif
HuMemDirectFree(temp_r31->hsfData);
HuMemDirectFreeNum(HEAP_DATA, temp_r31->unk_4C);
var_r28 = temp_r31->unk_C8;
@ -581,7 +584,7 @@ void Hu3DModelKill(s16 arg0) {
if (temp_r31->unk_20 != -1) {
for (i = 0; i < HU3D_MODEL_MAX; i++, var_r30++) {
if (var_r30->hsfData != 0 && var_r30->unk_24 != -1 && var_r30->unk_C8 == var_r28) {
Hu3DMotion[temp_r31->unk_20].unk_02 = i;
Hu3DMotion[temp_r31->unk_20].modelId = i;
break;
}
}
@ -592,7 +595,7 @@ void Hu3DModelKill(s16 arg0) {
return;
}
if (temp_r31->unk_20 != -1 && Hu3DMotionKill(temp_r31->unk_20) == 0) {
Hu3DMotion[temp_r31->unk_20].unk_02 = -1;
Hu3DMotion[temp_r31->unk_20].modelId = -1;
HuMemDirectFreeNum(HEAP_DATA, temp_r31->unk_48);
temp_r31->hsfData = NULL;
if (modelKillAllF == 0) {
@ -600,6 +603,9 @@ void Hu3DModelKill(s16 arg0) {
}
return;
}
#ifdef TARGET_PC
KillHSF(temp_r31->hsfData);
#endif
HuMemDirectFree(temp_r31->hsfData);
HuMemDirectFreeNum(HEAP_DATA, temp_r31->unk_48);
for (i = 0; i < temp_r31->unk_26; i++) {

213
src/game/hsfmotion.c
View file

@ -29,7 +29,7 @@ void Hu3DMotionInit(void)
var_r31 = (MotionData *)Hu3DData;
for (i = 0; i < HU3D_MOTION_MAX; i++, var_r31++) {
var_r31->unk_04 = 0;
var_r31->hsfData = 0;
}
}
@ -40,7 +40,7 @@ s16 Hu3DMotionCreate(void *arg0)
var_r31 = Hu3DMotion;
for (i = 0; i < HU3D_MOTION_MAX; i++, var_r31++) {
if (var_r31->unk_04 == 0) {
if (var_r31->hsfData == 0) {
break;
}
}
@ -48,9 +48,9 @@ s16 Hu3DMotionCreate(void *arg0)
OSReport("Error: Create Motion Over!\n");
return -1;
}
var_r31->unk_04 = LoadHSF(arg0);
var_r31->unk_00 = 0;
var_r31->unk_02 = -1;
var_r31->hsfData = LoadHSF(arg0);
var_r31->attr = 0;
var_r31->modelId = -1;
return i;
}
@ -62,7 +62,7 @@ s16 Hu3DMotionModelCreate(s16 arg0)
var_r31 = Hu3DMotion;
for (i = 0; i < HU3D_MOTION_MAX; i++, var_r31++) {
if (var_r31->unk_04 == 0) {
if (var_r31->hsfData == 0) {
break;
}
}
@ -70,9 +70,9 @@ s16 Hu3DMotionModelCreate(s16 arg0)
OSReport("Error: Create Motion Over!\n");
return -1;
}
var_r31->unk_04 = temp_r29->hsfData;
var_r31->unk_00 = 0;
var_r31->unk_02 = arg0;
var_r31->hsfData = temp_r29->hsfData;
var_r31->attr = 0;
var_r31->modelId = arg0;
temp_r29->unk_20 = i;
return i;
}
@ -84,25 +84,28 @@ s32 Hu3DMotionKill(s16 arg0)
s16 i;
temp_r31 = &Hu3DMotion[arg0];
if (temp_r31->unk_04 == 0) {
if (temp_r31->hsfData == 0) {
return 0;
}
var_r30 = Hu3DData;
for (i = 0; i < 512; i++, var_r30++) {
if (var_r30->hsfData && var_r30->unk_08 == arg0 && temp_r31->unk_02 != i) {
if (var_r30->hsfData && var_r30->unk_08 == arg0 && temp_r31->modelId != i) {
break;
}
}
if (i != 512) {
return 0;
}
if (temp_r31->unk_02 == -1) {
HuMemDirectFree(temp_r31->unk_04);
if (temp_r31->modelId == -1) {
#ifdef TARGET_PC
KillHSF(temp_r31->hsfData);
#endif
HuMemDirectFree(temp_r31->hsfData);
}
else {
Hu3DData[temp_r31->unk_02].unk_20 = -1;
Hu3DData[temp_r31->modelId].unk_20 = -1;
}
temp_r31->unk_04 = NULL;
temp_r31->hsfData = NULL;
return 1;
}
@ -113,7 +116,7 @@ void Hu3DMotionAllKill(void)
var_r27 = Hu3DMotion;
for (i = 0; i < HU3D_MOTION_MAX; i++, var_r27++) {
if (var_r27->unk_04) {
if (var_r27->hsfData) {
Hu3DMotionKill(i);
}
}
@ -259,7 +262,7 @@ s16 Hu3DMotionClusterSet(s16 arg0, s16 arg1)
temp_r31->unk_B4[i] = 1.0f;
temp_r31->cluster_attr[i] = HU3D_ATTR_NONE;
temp_r31->attr |= HU3D_ATTR_CLUSTER_ON;
ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].unk_04);
ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].hsfData);
return i;
}
}
@ -276,7 +279,7 @@ s16 Hu3DMotionClusterNoSet(s16 arg0, s16 arg1, s16 arg2)
temp_r31->unk_A4[arg2] = 0.0f;
temp_r31->unk_B4[arg2] = 1.0f;
temp_r31->attr |= HU3D_ATTR_CLUSTER_ON;
ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].unk_04);
ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].hsfData);
return arg2;
}
@ -366,7 +369,7 @@ float Hu3DMotionMaxTimeGet(s16 arg0)
return 0.0f;
}
temp_r30 = &Hu3DMotion[temp_r31->unk_08];
temp_r29 = temp_r30->unk_04->motion;
temp_r29 = temp_r30->hsfData->motion;
temp_r28 = 0.0001 + temp_r29->len;
return temp_r28;
}
@ -382,7 +385,7 @@ float Hu3DMotionShiftMaxTimeGet(s16 arg0)
return 0.0f;
}
temp_r30 = &Hu3DMotion[temp_r31->unk_0C];
temp_r29 = temp_r30->unk_04->motion;
temp_r29 = temp_r30->hsfData->motion;
temp_r28 = 0.0001 + temp_r29->len;
return temp_r28;
}
@ -401,10 +404,10 @@ float Hu3DMotionMotionMaxTimeGet(s16 arg0)
HsfMotion *temp_r30;
s16 temp_r29;
if (temp_r31->unk_04 == 0) {
if (temp_r31->hsfData == 0) {
return 0.0f;
}
temp_r30 = temp_r31->unk_04->motion;
temp_r30 = temp_r31->hsfData->motion;
temp_r29 = 0.0001 + temp_r30->len;
return temp_r29;
}
@ -526,7 +529,7 @@ void Hu3DMotionNext(s16 arg0)
s16 i;
temp_r27 = &Hu3DMotion[temp_r31->unk_08];
temp_r29 = temp_r27->unk_04->motion;
temp_r29 = temp_r27->hsfData->motion;
temp_r28 = temp_r31->motion_attr;
if (temp_r31->unk_08 != -1) {
temp_r27 = &Hu3DMotion[temp_r31->unk_08];
@ -555,7 +558,7 @@ void Hu3DMotionNext(s16 arg0)
}
if (temp_r31->unk_0A != -1) {
temp_r27 = &Hu3DMotion[temp_r31->unk_0A];
temp_r29 = temp_r27->unk_04->motion;
temp_r29 = temp_r27->hsfData->motion;
if (!(temp_r28 & HU3D_MOTATTR_OVL_PAUSE)) {
if (!(temp_r28 & HU3D_MOTATTR_OVL_REV)) {
temp_r31->unk_74 += temp_r31->unk_78 * minimumVcountf;
@ -629,7 +632,7 @@ void Hu3DMotionNext(s16 arg0)
}
if (temp_r31->unk_0E != -1 && !(temp_r28 & HU3D_MOTATTR_SHAPE_PAUSE)) {
temp_r27 = &Hu3DMotion[temp_r31->unk_0E];
temp_r29 = temp_r27->unk_04->motion;
temp_r29 = temp_r27->hsfData->motion;
if (!(temp_r28 & HU3D_MOTATTR_SHAPE_REV)) {
temp_r31->unk_94 += temp_r31->unk_98 * minimumVcountf;
}
@ -655,7 +658,7 @@ void Hu3DMotionNext(s16 arg0)
for (i = 0; i < 4; i++) {
if (temp_r31->unk_10[i] != -1 && !(temp_r31->cluster_attr[i] & HU3D_CLUSTER_ATTR_PAUSE)) {
temp_r27 = &Hu3DMotion[temp_r31->unk_10[i]];
temp_r29 = temp_r27->unk_04->motion;
temp_r29 = temp_r27->hsfData->motion;
if (!(temp_r31->cluster_attr[i] & HU3D_CLUSTER_ATTR_REV)) {
temp_r31->unk_A4[i] += temp_r31->unk_B4[i] * minimumVcountf;
}
@ -692,7 +695,7 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
HsfObject *temp_r31;
HsfObject *var_r19;
HsfCluster *var_r23;
HsfTrack *var_r30;
HsfTrack *track;
HsfTrack *temp_r25;
HsfTrack *temp_r22;
HsfTrack *var_r26;
@ -704,9 +707,9 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
temp_r27 = &Hu3DData[arg0];
sp18 = &Hu3DMotion[arg1];
temp_r29 = temp_r27->hsfData;
sp14 = sp18->unk_04;
sp14 = sp18->hsfData;
temp_r21 = sp14->motion;
var_r30 = temp_r21->track;
track = temp_r21->track;
var_r19 = temp_r29->object;
if (arg3 == 0) {
for (var_r18 = 0; var_r18 < temp_r29->objectCnt; var_r19++, var_r18++) {
@ -743,27 +746,27 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
}
}
}
sp10 = &var_r30[temp_r21->numTracks];
for (; var_r30 < sp10; var_r30++) {
switch (var_r30->type) {
case 2:
if (var_r30->target < temp_r29->objectCnt && var_r30->target != -1) {
temp_r31 = &temp_r29->object[var_r30->target];
if (var_r30->channel == 0x28) {
temp_r31->data.mesh.baseMorph = GetCurve(var_r30, arg2);
sp10 = &track[temp_r21->numTracks];
for (; track < sp10; track++) {
switch (track->type) {
case HSF_TRACK_TRANSFORM:
if (track->target < temp_r29->objectCnt && track->target != -1) {
temp_r31 = &temp_r29->object[track->target];
if (track->channel == 0x28) {
temp_r31->data.mesh.baseMorph = GetCurve(track, arg2);
}
else if (temp_r31->type == 7) {
if (temp_r27->attr & HU3D_ATTR_CAMERA_MOTON) {
SetObjCameraMotion(arg0, var_r30, GetCurve(var_r30, arg2));
SetObjCameraMotion(arg0, track, GetCurve(track, arg2));
}
}
else if (temp_r31->type == 8) {
SetObjLightMotion(arg0, var_r30, GetCurve(var_r30, arg2));
SetObjLightMotion(arg0, track, GetCurve(track, arg2));
}
else if (var_r30->channel == 0x18) {
else if (track->channel == 0x18) {
if (temp_r31->constData) {
temp_r28 = temp_r31->constData;
if (GetCurve(var_r30, arg2) == 1.0f) {
if (GetCurve(track, arg2) == 1.0f) {
temp_r28->flags &= ~0x1000;
}
else {
@ -771,10 +774,10 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
}
}
}
else if (var_r30->channel == 0x1A) {
else if (track->channel == 0x1A) {
if (temp_r31->constData) {
temp_r28 = temp_r31->constData;
if (GetCurve(var_r30, arg2) == 1.0f) {
if (GetCurve(track, arg2) == 1.0f) {
temp_r28->flags &= ~0x2000;
}
else {
@ -783,42 +786,42 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
}
}
else {
temp_r17 = GetObjTRXPtr(temp_r31, var_r30->channel);
temp_r17 = GetObjTRXPtr(temp_r31, track->channel);
if (temp_r17 != (float *)-1) {
*temp_r17 = GetCurve(var_r30, arg2);
*temp_r17 = GetCurve(track, arg2);
}
}
}
break;
case 3:
temp_r25 = var_r30;
case HSF_TRACK_MORPH:
temp_r25 = track;
if (temp_r25->target < temp_r29->objectCnt) {
temp_r31 = &temp_r29->object[temp_r25->target];
temp_r31->data.mesh.morphWeight[temp_r25->channel_s16] = GetCurve(temp_r25, arg2);
}
break;
case 9:
case HSF_TRACK_MATERIAL:
if (!(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
if (var_r30->param < temp_r29->materialCnt) {
SetObjMatMotion(arg0, var_r30, GetCurve(var_r30, arg2));
if (track->param < temp_r29->materialCnt) {
SetObjMatMotion(arg0, track, GetCurve(track, arg2));
}
}
break;
case 5:
case HSF_TRACK_CLUSTER:
if (!(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
var_r23 = &temp_r29->cluster[var_r30->target_s16];
var_r23->index = GetClusterCurve(var_r30, arg2);
var_r23 = &temp_r29->cluster[track->target_s16];
var_r23->index = GetClusterCurve(track, arg2);
}
break;
case 6:
case HSF_TRACK_CLUSTER_WEIGHT:
if (!(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
temp_r22 = var_r30;
temp_r22 = track;
var_r23 = &temp_r29->cluster[temp_r22->target_s16];
var_r23->weight[temp_r22->unk04] = GetClusterWeightCurve(temp_r22, arg2);
}
break;
case 10:
var_r26 = var_r30;
case HSF_TRACK_ATTRIBUTE:
var_r26 = track;
if (var_r26->target_s16 != -1 || !(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
if (var_r26->param != -1 && var_r26->param < temp_r29->attributeCnt) {
SetObjAttrMotion(arg0, var_r26, GetCurve(var_r26, arg2));
@ -834,20 +837,20 @@ void Hu3DCameraMotionExec(s16 arg0)
ModelData *temp_r30;
MotionData *temp_r28;
HsfData *temp_r27;
HsfMotion *temp_r29;
HsfTrack *var_r31;
HsfMotion *motion;
HsfTrack *track;
HsfTrack *temp_r26;
temp_r30 = &Hu3DData[arg0];
temp_r28 = &Hu3DMotion[temp_r30->unk_08];
temp_r27 = temp_r28->unk_04;
temp_r29 = temp_r27->motion;
var_r31 = temp_r29->track;
temp_r27 = temp_r28->hsfData;
motion = temp_r27->motion;
track = motion->track;
if (temp_r30->attr & HU3D_ATTR_CAMERA_MOTON) {
temp_r26 = &var_r31[temp_r29->numTracks];
for (; var_r31 < temp_r26; var_r31++) {
if (var_r31->type == 2 && var_r31->param_u16 == 7) {
SetObjCameraMotion(arg0, var_r31, GetCurve(var_r31, temp_r30->unk_64));
temp_r26 = &track[motion->numTracks];
for (; track < temp_r26; track++) {
if (track->type == HSF_TRACK_TRANSFORM && track->param_u16 == 7) {
SetObjCameraMotion(arg0, track, GetCurve(track, temp_r30->unk_64));
}
}
}
@ -859,8 +862,8 @@ void Hu3DSubMotionExec(s16 arg0)
MotionData *temp_r22;
HsfData *temp_r28;
HsfData *temp_r21;
HsfMotion *temp_r25;
HsfTrack *var_r29;
HsfMotion *motion;
HsfTrack *track;
HsfObject *var_r23;
HsfObject *temp_r26;
float *temp_r31;
@ -872,9 +875,9 @@ void Hu3DSubMotionExec(s16 arg0)
temp_r30 = &Hu3DData[arg0];
temp_r22 = &Hu3DMotion[temp_r30->unk_0C];
temp_r28 = temp_r30->hsfData;
temp_r21 = temp_r22->unk_04;
temp_r25 = temp_r21->motion;
var_r29 = temp_r25->track;
temp_r21 = temp_r22->hsfData;
motion = temp_r21->motion;
track = motion->track;
var_r23 = temp_r28->object;
if (temp_r30->unk_08 == -1) {
for (var_r27 = 0; var_r27 < temp_r28->objectCnt; var_r23++, var_r27++) {
@ -888,16 +891,16 @@ void Hu3DSubMotionExec(s16 arg0)
else {
var_f30 = 1.0f;
}
for (var_r27 = 0; var_r27 < temp_r25->numTracks; var_r27++, var_r29++) {
switch (var_r29->type) {
case 2:
if (var_r29->target < temp_r28->objectCnt && var_r29->target != -1) {
temp_r26 = &temp_r28->object[var_r29->target];
temp_r24 = var_r29->channel;
for (var_r27 = 0; var_r27 < motion->numTracks; var_r27++, track++) {
switch (track->type) {
case HSF_TRACK_TRANSFORM:
if (track->target < temp_r28->objectCnt && track->target != -1) {
temp_r26 = &temp_r28->object[track->target];
temp_r24 = track->channel;
temp_r31 = GetObjTRXPtr(temp_r26, temp_r24);
if (temp_r31 != (float *)-1) {
if (temp_r24 == 0x1C || temp_r24 == 0x1D || temp_r24 == 0x1E) {
var_f31 = GetCurve(var_r29, temp_r30->unk_84);
var_f31 = GetCurve(track, temp_r30->unk_84);
if (var_f31 < 0.0f) {
var_f31 += 360.0f;
}
@ -915,7 +918,7 @@ void Hu3DSubMotionExec(s16 arg0)
*temp_r31 = (1.0f - var_f30) * *temp_r31 + var_f30 * var_f31;
}
else {
*temp_r31 = (1.0f - var_f30) * *temp_r31 + var_f30 * GetCurve(var_r29, temp_r30->unk_84);
*temp_r31 = (1.0f - var_f30) * *temp_r31 + var_f30 * GetCurve(track, temp_r30->unk_84);
}
}
}
@ -1232,7 +1235,7 @@ void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2)
var_r26 = temp_r28->object;
for (i = var_r29 = 0; i < temp_r28->objectCnt; i++, var_r26++) {
var_r24 = var_r26;
if (var_r24->type == 8) {
if (var_r24->type == HSF_OBJ_NONE2) {
if (i != arg1->target) {
var_r29++;
}
@ -1276,23 +1279,23 @@ void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2)
}
}
float GetCurve(HsfTrack *arg0, float arg1)
float GetCurve(HsfTrack *track, float arg1)
{
float *var_r30;
switch (arg0->curveType) {
case 1:
return GetLinear(arg0->numKeyframes, arg0->data, arg1);
case 2:
return GetBezier(arg0->numKeyframes, arg0, arg1);
case 3:
bitMapPtr = GetBitMap(arg0->numKeyframes, arg0->data, arg1);
switch (track->curveType) {
case HSF_CURVE_LINEAR:
return GetLinear(track->numKeyframes, track->data, arg1);
case HSF_CURVE_BEZIER:
return GetBezier(track->numKeyframes, track, arg1);
case HSF_CURVE_BITMAP:
bitMapPtr = GetBitMap(track->numKeyframes, track->data, arg1);
break;
case 4:
var_r30 = &arg0->value;
case HSF_CURVE_CONST:
var_r30 = &track->value;
return *var_r30;
case 0:
return GetConstant(arg0->numKeyframes, arg0->data, arg1);
case HSF_CURVE_STEP:
return GetConstant(track->numKeyframes, track->data, arg1);
}
return 0.0f;
}
@ -1427,8 +1430,8 @@ void JointModel_Motion(s16 arg0, s16 arg1)
MotionData *temp_r23;
HsfData *temp_r26;
HsfData *temp_r22;
HsfMotion *temp_r29;
HsfTrack *var_r30;
HsfMotion *motion;
HsfTrack *track;
HsfTrack *var_r28;
HsfTrack *var_r27;
HsfTrack *var_r31;
@ -1438,21 +1441,21 @@ void JointModel_Motion(s16 arg0, s16 arg1)
temp_r24 = &Hu3DData[arg0];
temp_r23 = &Hu3DMotion[arg1];
temp_r26 = temp_r24->hsfData;
temp_r22 = temp_r23->unk_04;
temp_r29 = temp_r22->motion;
var_r30 = temp_r29->track;
for (i = 0; i < temp_r29->numTracks; i++, var_r30++) {
switch (var_r30->type) {
case 2:
var_r28 = var_r30;
temp_r22 = temp_r23->hsfData;
motion = temp_r22->motion;
track = motion->track;
for (i = 0; i < motion->numTracks; i++, track++) {
switch (track->type) {
case HSF_TRACK_TRANSFORM:
var_r28 = track;
var_r28->target = SearchObjectIndex(temp_r26, var_r28->target);
break;
case 3:
var_r27 = var_r30;
case HSF_TRACK_MORPH:
var_r27 = track;
var_r27->target = SearchObjectIndex(temp_r26, var_r27->target);
break;
case 10:
var_r31 = var_r30;
case HSF_TRACK_ATTRIBUTE:
var_r31 = track;
if (var_r31->param == -1) {
temp_r21 = SearchAttributeIndex(temp_r26, var_r31->target_s16);
if (temp_r21 != -1) {

155
src/port/byteswap.cpp
View file

@ -45,7 +45,6 @@ typedef struct AnimBmpData32b {
u32 palData;
u32 data;
} AnimBmpData32b;
}
template <typename T> [[nodiscard]] constexpr T bswap16(T val) noexcept
@ -208,6 +207,13 @@ template <typename B> void bswap(B &base, Vec2f &vec)
bswap(base, vec.y);
}
template <typename B> void bswap(B &base, HsfVector3f &vec)
{
bswap(base, vec.x);
bswap(base, vec.y);
bswap(base, vec.z);
}
template <typename B> void bswap(B &base, AnimData32b &obj, AnimData &dest)
{
bswap(base, obj.bankNum);
@ -459,7 +465,7 @@ template <typename B> void bswap(B &base, HsfMatrix &obj)
bswap_flat(base, obj.data[i][j], 4);
}
}
}
}
template <typename B> void bswap(B &base, HsfPalette32b &obj, HsfPalette &dest)
{
@ -582,6 +588,74 @@ template <typename B> void bswap(B &base, HsfCenv32b &obj, HsfCenv &dest)
dest.copyCount = obj.copyCount;
}
template <typename B> void bswap(B &base, HsfObjectData32b &obj, HsfObjectData &dest, u32 type)
{
bswap(base, obj.parent);
bswap(base, obj.childrenCount);
bswap(base, obj.children);
bswap(base, obj.base);
bswap(base, obj.curr);
bswap(base, obj.face);
bswap(base, obj.vertex);
bswap(base, obj.normal);
bswap(base, obj.color);
bswap(base, obj.st);
bswap(base, obj.material);
bswap(base, obj.attribute);
bswap(base, obj.vertexShapeCnt);
bswap(base, obj.vertexShape);
bswap(base, obj.clusterCnt);
bswap(base, obj.cluster);
bswap(base, obj.cenvCnt);
bswap(base, obj.cenv);
bswap_flat(base, obj.file, sizeof(obj.file) / sizeof(u32));
dest.parent = reinterpret_cast<struct hsf_object *>(obj.parent);
dest.childrenCount = obj.childrenCount;
dest.children = reinterpret_cast<struct hsf_object **>(obj.children);
dest.base = obj.base;
dest.curr = obj.curr;
dest.face = reinterpret_cast<HsfBuffer *>(obj.face);
dest.vertex = reinterpret_cast<HsfBuffer *>(obj.vertex);
dest.normal = reinterpret_cast<HsfBuffer *>(obj.normal);
dest.color = reinterpret_cast<HsfBuffer *>(obj.color);
dest.st = reinterpret_cast<HsfBuffer *>(obj.st);
dest.material = reinterpret_cast<HsfMaterial *>(obj.material);
dest.attribute = reinterpret_cast<HsfAttribute *>(obj.attribute);
std::copy(std::begin(obj.unk120), std::end(obj.unk120), dest.unk120);
dest.shapeType = obj.shapeType;
dest.unk123 = obj.unk123;
dest.vertexShapeCnt = obj.vertexShapeCnt;
dest.vertexShape = reinterpret_cast<HsfBuffer **>(obj.vertexShape);
dest.clusterCnt = obj.clusterCnt;
dest.cluster = reinterpret_cast<HsfCluster **>(obj.cluster);
dest.cenvCnt = obj.cenvCnt;
dest.cenv = reinterpret_cast<HsfCenv *>(obj.cenv);
dest.file[0] = reinterpret_cast<void *>(obj.file[0]);
dest.file[1] = reinterpret_cast<void *>(obj.file[1]);
switch (type) {
case HSF_OBJ_MESH:
bswap(base, obj.mesh.min);
bswap(base, obj.mesh.max);
bswap(base, obj.mesh.baseMorph);
bswap_flat(base, obj.mesh.morphWeight, std::size(obj.mesh.morphWeight));
dest.mesh.min = obj.mesh.min;
dest.mesh.max = obj.mesh.max;
dest.mesh.baseMorph = obj.mesh.baseMorph;
std::copy(std::begin(obj.mesh.morphWeight), std::end(obj.mesh.morphWeight), dest.mesh.morphWeight);
break;
case HSF_OBJ_REPLICA:
bswap(base, obj.replica);
dest.replica = obj.replica;
break;
default:
break;
}
}
template <typename B> void bswap(B &base, HsfObject32b &obj, HsfObject &dest)
{
bswap(base, obj.name);
@ -593,6 +667,58 @@ template <typename B> void bswap(B &base, HsfObject32b &obj, HsfObject &dest)
dest.type = obj.type;
dest.constData = reinterpret_cast<void *>(obj.constData);
dest.flags = obj.flags;
bswap(base, obj.data, dest.data, obj.type);
}
template <typename B> void bswap(B &base, HsfBitmapKey32b &obj, HsfBitmapKey &dest)
{
bswap(base, obj.time);
bswap(base, obj.data);
dest.time = obj.time;
dest.data = reinterpret_cast<HsfBitmap *>(obj.data);
}
template <typename B> void bswap(B &base, HsfTrack32b &obj, HsfTrack &dest)
{
bswap(base, obj.type);
bswap(base, obj.start);
bswap(base, obj.curveType);
bswap(base, obj.numKeyframes);
bswap(base, obj.data); // this byteswaps "value" too
dest.type = obj.type;
dest.start = obj.start;
dest.curveType = obj.curveType;
dest.numKeyframes = obj.numKeyframes;
dest.data = reinterpret_cast<void *>(obj.data); // this correctly sets "value" too
if (obj.type = HSF_TRACK_CLUSTER_WEIGHT) {
bswap(base, obj.unk04);
dest.unk04 = obj.unk04;
}
else {
bswap(base, obj.param);
bswap(base, obj.channel);
dest.param = obj.param;
dest.channel = obj.channel;
}
}
template <typename B> void bswap(B &base, HsfMotion32b &obj, HsfMotion &dest)
{
bswap(base, obj.name);
bswap(base, obj.numTracks);
bswap(base, obj.track);
bswap(base, obj.len);
dest.name = reinterpret_cast<char *>(obj.name);
dest.numTracks = obj.numTracks;
dest.track = reinterpret_cast<HsfTrack *>(obj.track);
dest.len = obj.len;
}
void byteswap_u16(u16 *src)
@ -621,8 +747,7 @@ void byteswap_s32(s32 *src)
void byteswap_hsfvec3f(HsfVector3f *src)
{
auto *vec = reinterpret_cast<Vec *>(src);
bswap(*vec, *vec);
bswap(*src, *src);
sVisitedPtrs.clear();
}
@ -751,7 +876,7 @@ void byteswap_hsfshape(HsfShape32b *src, HsfShape *dest)
sVisitedPtrs.clear();
}
void byteswap_hsfcenvsingle(HsfCenvSingle *src)
void byteswap_hsfcenv_single(HsfCenvSingle *src)
{
bswap(*src, *src);
sVisitedPtrs.clear();
@ -764,6 +889,26 @@ void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest)
}
void byteswap_hsfobject(HsfObject32b *src, HsfObject *dest)
{
bswap(*src, *src, *dest);
sVisitedPtrs.clear();
}
void byteswap_hsfbitmapkey(HsfBitmapKey32b *src, HsfBitmapKey *dest)
{
bswap(*src, *src, *dest);
sVisitedPtrs.clear();
}
void byteswap_hsftrack(HsfTrack32b *src, HsfTrack *dest)
{
bswap(*src, *src, *dest);
sVisitedPtrs.clear();
}
void byteswap_hsfmotion(HsfMotion32b *src, HsfMotion *dest)
{
bswap(*src, *src, *dest);
sVisitedPtrs.clear();