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

hsfload fixes

Browse source
This commit is contained in:
dbalatoni13 2025-04-15 05:15:22 +02:00
parent 316d80a0ae
commit 7628f37163
12 changed files with 187 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/game/hsfdraw.h
View file

@ -70,7 +70,7 @@ void Hu3DModelObjMtxGet(s16 arg0, char *arg1, Mtx arg2);
void PGObjCall(ModelData *arg0, HsfObject *arg1);
void PGObjCalc(ModelData *arg0, HsfObject *arg1);
void PGObjReplica(ModelData *arg0, HsfObject *arg1);
HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1);
HsfObject *Hu3DObjDuplicate(HsfData *arg0, uintptr_t arg1);
void Hu3DModelObjDrawInit(void);
void Hu3DModelObjDraw(s16 arg0, char *arg1, Mtx arg2);

3
include/game/hsfformat.h
View file

@ -277,7 +277,8 @@ typedef struct hsf_object_data {
HsfCluster **cluster;
u32 cenvCnt;
HsfCenv *cenv;
void *file[2];
HsfVector3f *vtxtop;
HsfVector3f *normtop;
} HsfObjectData;
typedef struct hsf_camera {

32
include/port/byteswap.h
View file

@ -156,6 +156,22 @@ typedef struct HsfShape32b {
u32 vertex;
} HsfShape32b;
typedef struct HsfCenvDual32b {
u32 target1;
u32 target2;
u32 weightCnt;
u32 weight;
} HsfCenvDual32b;
typedef struct HsfCenvMulti32b {
u32 weightCnt;
u16 pos;
u16 posCnt;
u16 normal;
u16 normalCnt;
u32 weight;
} HsfCenvMulti32b;
typedef struct HsfCenv32b {
u32 name;
u32 singleData;
@ -200,7 +216,8 @@ typedef struct HsfObjectData32b {
u32 cluster;
u32 cenvCnt;
u32 cenv;
u32 file[2];
u32 vtxtop;
u32 normtop;
} HsfObjectData32b;
typedef struct HsfObject32b {
@ -265,6 +282,12 @@ typedef struct HsfFace32b {
Vec nbt;
} HsfFace32b;
typedef struct HsfMatrix32b {
u32 base_idx;
u32 count;
u32 data;
} HsfMatrix32b;
void byteswap_u16(u16 *src);
void byteswap_s16(s16 *src);
void byteswap_u32(u32 *src);
@ -285,7 +308,7 @@ void byteswap_hsfattribute(HsfAttribute32b *src, HsfAttribute *dest);
void byteswap_hsfmaterial(HsfMaterial32b *src, HsfMaterial *dest);
void byteswap_hsfscene(HsfScene *src);
void byteswap_hsfbuffer(HsfBuffer32b *src, HsfBuffer *dest);
void byteswap_hsfmatrix(HsfMatrix *src);
void byteswap_hsfmatrix(HsfMatrix32b *src, HsfMatrix *dest);
void byteswap_hsfpalette(HsfPalette32b *src, HsfPalette *dest);
void byteswap_hsfpart(HsfPart32b *src, HsfPart *dest);
void byteswap_hsfbitmap(HsfBitmap32b *src, HsfBitmap *dest);
@ -304,7 +327,6 @@ void byteswap_hsfattribute(HsfAttribute32b *src, HsfAttribute *dest);
void byteswap_hsfmaterial(HsfMaterial32b *src, HsfMaterial *dest);
void byteswap_hsfscene(HsfScene *src);
void byteswap_hsfbuffer(HsfBuffer32b *src, HsfBuffer *dest);
void byteswap_hsfmatrix(HsfMatrix *src);
void byteswap_hsfpalette(HsfPalette32b *src, HsfPalette *dest);
void byteswap_hsfpart(HsfPart32b *src, HsfPart *dest);
void byteswap_hsfbitmap(HsfBitmap32b *src, HsfBitmap *dest);
@ -312,6 +334,10 @@ void byteswap_hsfmapattr(HsfMapAttr32b *src, HsfMapAttr *dest);
void byteswap_hsfskeleton(HsfSkeleton32b *src, HsfSkeleton *dest);
void byteswap_hsfshape(HsfShape32b *src, HsfShape *dest);
void byteswap_hsfcenv_single(HsfCenvSingle *src);
void byteswap_hsfcenv_dual_weight(HsfCenvDualWeight *src);
void byteswap_hsfcenv_dual(HsfCenvDual32b *src, HsfCenvDual *dest);
void byteswap_hsfcenv_multi_weight(HsfCenvMultiWeight *src);
void byteswap_hsfcenv_multi(HsfCenvMulti32b *src, HsfCenvMulti *dest);
void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest);
void byteswap_hsfobject(HsfObject32b *src, HsfObject *dest);
void byteswap_hsfbitmapkey(HsfBitmapKey32b *src, HsfBitmapKey *dest);

4
src/dolphin/mtx/mtx.c
View file

@ -1322,8 +1322,8 @@ void C_MTXLightOrtho(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT,
void C_MTXReorder(const Mtx src, ROMtx dest)
{
u32 i, j;
for (i = 0; i < 3; j++) {
for (int j = 0; j < 4; j++) {
for (i = 0; i < 3; i++) {
for (j = 0; j < 4; j++) {
dest[j][i] = src[i][j];
}
}

6
src/game/ClusterExec.c
View file

@ -127,9 +127,9 @@ void ClusterProc(ModelData *arg0)
Vertextop = temp_r31->data.vertex->data;
if (temp_r31->data.cenvCnt) {
for (k = 0; k < temp_r31->data.vertex->count; k++) {
Vertextop[k].x = ((Vec *)temp_r31->data.file[0])[k].x;
Vertextop[k].y = ((Vec *)temp_r31->data.file[0])[k].y;
Vertextop[k].z = ((Vec *)temp_r31->data.file[0])[k].z;
Vertextop[k].x = ((Vec *)temp_r31->data.vtxtop)[k].x;
Vertextop[k].y = ((Vec *)temp_r31->data.vtxtop)[k].y;
Vertextop[k].z = ((Vec *)temp_r31->data.vtxtop)[k].z;
}
}
SetClusterMain(var_r29);

8
src/game/EnvelopeExec.c
View file

@ -36,7 +36,7 @@ void InitEnvelope(HsfData *arg0) {
var_r31 = arg0->object;
for (Meshcnt = i = 0; i < arg0->objectCnt; i++, var_r31++) {
if (var_r31->type == 2) {
if (var_r31->data.file[0]) {
if (var_r31->data.vtxtop) {
spC = var_r31->data.vertex;
sp8 = var_r31->data.normal;
Meshcnt++;
@ -173,17 +173,17 @@ static void SetEnvelopMain(HsfData *arg0) {
if (var_r31->data.unk120[0] != 0) {
Vertextop = temp_r30->data;
} else {
Vertextop = var_r31->data.file[0];
Vertextop = (Vec*)var_r31->data.vtxtop;
}
vtxenv = temp_r30->data;
normtop = var_r31->data.file[1];
normtop = (Vec*)var_r31->data.normtop;
normenv = temp_r28->data;
var_r25 = var_r31->data.cenv;
for (j = 0; j < var_r31->data.cenvCnt; j++, var_r25++) {
SetEnvelop(var_r25);
}
sp10 = temp_r30->data;
spC = var_r31->data.file[0];
spC = var_r31->data.vtxtop;
sp8 = temp_r30->data;
DCStoreRangeNoSync(normenv, temp_r28->count * sizeof(Vec));
DCStoreRangeNoSync(vtxenv, temp_r30->count * sizeof(Vec));

2
src/game/armem.c
View file

@ -344,7 +344,7 @@ void *HuAR_ARAMtoMRAMFileRead(u32 dir, u32 num, HeapID heap) {
DCInvalidateRange(&preLoadBuf, sizeof(preLoadBuf));
amem_src = amemptr + (u32)((u32)(((u16)dir + 1) * 4) & 0xFFFFFFFE0);
arqCnt++;
ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (u32) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (uintptr_t) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
arqIdx++;
arqIdx &= 0xF;
while (HuARDMACheck());

9
src/game/data.c
View file

@ -286,10 +286,11 @@ BOOL HuDataGetAsyncStat(s32 status)
static void GetFileInfo(DataReadStat *read_stat, s32 file_num)
{
u32 *temp_ptr;
temp_ptr = (u32 *)PTR_OFFSET(read_stat->dir, (file_num * 4))+1;
u32 *temp_ptr = (u32 *)PTR_OFFSET(read_stat->dir, (file_num * 4))+1;
#ifdef TARGET_PC
byteswap_u32(temp_ptr);
u32 ofs = *temp_ptr;
byteswap_u32(&ofs);
temp_ptr = &ofs;
#endif
read_stat->file = PTR_OFFSET(read_stat->dir, *temp_ptr);
temp_ptr = read_stat->file;
@ -336,7 +337,7 @@ void *HuDataReadNum(s32 data_num, s32 num)
}
read_stat = &ReadDataStat[status];
GetFileInfo(read_stat, data_num & 0xFFFF);
buf = HuMemDirectMallocNum(0, DATA_EFF_SIZE(read_stat->raw_len), num);
buf = HuMemDirectMallocNum(HEAP_SYSTEM, DATA_EFF_SIZE(read_stat->raw_len), num);
if(buf) {
HuDecodeData(read_stat->file, buf, read_stat->raw_len, read_stat->comp_type);
}

7
src/game/hsfdraw.c
View file

@ -3347,14 +3347,13 @@ void PGObjReplica(ModelData *arg0, HsfObject *arg1)
}
}
HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1)
HsfObject *Hu3DObjDuplicate(HsfData *arg0, uintptr_t arg1)
{
HsfObject *temp_r27;
HsfObject *var_r30;
HsfObject *var_r31;
s16 i;
s16 j;
var_r31 = HuMemDirectMallocNum(HEAP_DATA, arg0->objectCnt * sizeof(HsfObject), arg1);
temp_r27 = var_r31;
var_r30 = arg0->object;
@ -3362,7 +3361,7 @@ HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1)
for (i = 0; i < arg0->objectCnt; i++, var_r31++, var_r30++) {
if (var_r31->type != 8 && var_r31->type != 7) {
if (var_r31->data.parent) {
var_r31->data.parent = (HsfObject *)((u8 *)temp_r27 + ((u32)var_r30->data.parent - (u32)arg0->object));
var_r31->data.parent = (HsfObject *)((u8 *)temp_r27 + ((uintptr_t)var_r30->data.parent - (uintptr_t)arg0->object));
}
var_r31->data.children = HuMemDirectMallocNum(HEAP_DATA, var_r30->data.childrenCount * 4, arg1);
if (var_r30->constData) {
@ -3370,7 +3369,7 @@ HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1)
memcpy(var_r31->constData, var_r30->constData, sizeof(HsfConstData));
}
for (j = 0; j < var_r30->data.childrenCount; j++) {
var_r31->data.children[j] = (HsfObject *)((u8 *)temp_r27 + ((u32)var_r30->data.children[j] - (u32)arg0->object));
var_r31->data.children[j] = (HsfObject *)((u8 *)temp_r27 + ((uintptr_t)var_r30->data.children[j] - (uintptr_t)arg0->object));
}
}
}

68
src/game/hsfload.c
View file

@ -1,6 +1,8 @@
#include "game/hsfload.h"
#include "string.h"
#include "game/EnvelopeExec.h"
#include "ctype.h"
#include "string.h"
#ifdef TARGET_PC
#include "game/memory.h"
@ -89,7 +91,9 @@ HsfData *LoadHSF(void *data)
NormalLoad();
STLoad();
FaceLoad();
#if __MWERKS__
ObjectLoad();
#endif
CenvLoad();
SkeletonLoad();
PartLoad();
@ -98,6 +102,10 @@ HsfData *LoadHSF(void *data)
MapAttrLoad();
MotionLoad();
MatrixLoad();
#if TARGET_PC
// to properly set pointers
ObjectLoad();
#endif
hsf = SetHsfModel();
InitEnvelope(hsf);
objtop = NULL;
@ -448,7 +456,7 @@ static void NormalLoad(void)
Model.normal = new_normal;
Model.normalCnt = head.normal.count;
#ifdef TARGET_PC
VertexDataTop = data = (void *)&file_normal_real[head.normal.count];
NormalDataTop = 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];
@ -460,8 +468,8 @@ static void NormalLoad(void)
new_normal->data = (void *)((uintptr_t)data+(uintptr_t)temp_data);
#ifdef TARGET_PC
if (cenv_count != 0) {
for (i = 0; i < new_normal->count; i++) {
HsfVector3f *normalData = &((HsfVector3f *)new_normal->data)[i];
for (j = 0; j < new_normal->count; j++) {
HsfVector3f *normalData = &((HsfVector3f *)new_normal->data)[j];
byteswap_hsfvec3f(normalData);
}
}
@ -647,8 +655,16 @@ static void DispObject(HsfObject *parent, HsfObject *object)
} else {
new_object->data.attribute = NULL;
}
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.vtxtop = (void *)((uintptr_t)fileptr + (uintptr_t)data->vtxtop);
new_object->data.normtop = (void *)((uintptr_t)fileptr + (uintptr_t)data->normtop);
#ifdef TARGET_PC
for (i = 0; i < new_object->data.vertex->count; i++) {
byteswap_hsfvec3f(&new_object->data.vtxtop[i]);
}
for (i = 0; i < new_object->data.normal->count; i++) {
byteswap_hsfvec3f(&new_object->data.normtop[i]);
}
#endif
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;
@ -906,46 +922,70 @@ static void CenvLoad(void)
Model.cenv = cenv_file;
for(i=0; i<head.cenv.count; i++) {
cenv_new[i].singleData = (HsfCenvSingle *)((uintptr_t)cenv_file[i].singleData + (uintptr_t)data_base);
#ifdef __MWERKS__
cenv_new[i].dualData = (HsfCenvDual *)((uintptr_t)cenv_file[i].dualData + (uintptr_t)data_base);
cenv_new[i].multiData = (HsfCenvMulti *)((uintptr_t)cenv_file[i].multiData + (uintptr_t)data_base);
#endif
cenv_new[i].singleCount = cenv_file[i].singleCount;
cenv_new[i].dualCount = cenv_file[i].dualCount;
cenv_new[i].multiCount = cenv_file[i].multiCount;
cenv_new[i].copyCount = cenv_file[i].copyCount;
cenv_new[i].vtxCount = cenv_file[i].vtxCount;
#if TARGET_PC
weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].singleCount * sizeof(HsfCenvSingle)));
weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].dualCount * sizeof(HsfCenvDual32b)));
weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].multiCount * sizeof(HsfCenvMulti32b)));
#else
weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].singleCount * sizeof(HsfCenvSingle)));
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_hsfcenv_single(cenv_new[i].singleData);
// TODO PC malloc dual, multi etc and byteswap them
#endif
}
for(i=0; i<head.cenv.count; i++) {
#ifdef TARGET_PC
HsfCenvDual32b *dual_data_real = (HsfCenvDual32b *)((uintptr_t)cenv_file[i].dualData + (uintptr_t)data_base);
HsfCenvMulti32b *multi_data_real = (HsfCenvMulti32b *)((uintptr_t)cenv_file[i].multiData + (uintptr_t)data_base);
cenv_new[i].dualData = HuMemDirectMallocNum(HEAP_DATA, cenv_file[i].dualCount * sizeof(HsfCenvDual), MEMORY_DEFAULT_NUM);
cenv_new[i].multiData = HuMemDirectMallocNum(HEAP_DATA, cenv_file[i].multiCount * sizeof(HsfCenvMulti), MEMORY_DEFAULT_NUM);
#endif
single_new = single_file = cenv_new[i].singleData;
for(j=0; j<cenv_new[i].singleCount; j++) {
#ifdef TARGET_PC
byteswap_hsfcenv_single(&single_new[j]);
#endif
single_new[j].target = single_file[j].target;
single_new[j].posCnt = single_file[j].posCnt;
single_new[j].pos = single_file[j].pos;
single_new[j].normalCnt = single_file[j].normalCnt;
single_new[j].normal = single_file[j].normal;
}
dual_new = dual_file = cenv_new[i].dualData;
for(j=0; j<cenv_new[i].dualCount; j++) {
#ifdef TARGET_PC
byteswap_hsfcenv_dual(&dual_data_real[j], &dual_new[j]);
#endif
dual_new[j].target1 = dual_file[j].target1;
dual_new[j].target2 = dual_file[j].target2;
dual_new[j].weightCnt = dual_file[j].weightCnt;
dual_new[j].weight = (HsfCenvDualWeight *)((uintptr_t)weight_base + (uintptr_t)dual_file[j].weight);
#ifdef TARGET_PC
byteswap_hsfcenv_dual_weight(dual_new[j].weight);
#endif
}
multi_new = multi_file = cenv_new[i].multiData;
for(j=0; j<cenv_new[i].multiCount; j++) {
#ifdef TARGET_PC
byteswap_hsfcenv_multi(&multi_data_real[j], &multi_new[j]);
#endif
multi_new[j].weightCnt = multi_file[j].weightCnt;
multi_new[j].pos = multi_file[j].pos;
multi_new[j].posCnt = multi_file[j].posCnt;
multi_new[j].normal = multi_file[j].normal;
multi_new[j].normalCnt = multi_file[j].normalCnt;
multi_new[j].weight = (HsfCenvMultiWeight *)((uintptr_t)weight_base + (uintptr_t)multi_file[j].weight);
#ifdef TARGET_PC
byteswap_hsfcenv_multi_weight(dual_new[j].weight);
#endif
}
dual_new = dual_file = cenv_new[i].dualData;
for(j=0; j<cenv_new[i].dualCount; j++) {
@ -1686,7 +1726,7 @@ static void MatrixLoad(void)
if(head.matrix.count) {
#ifdef TARGET_PC
matrix_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMatrix) * head.matrix.count, MEMORY_DEFAULT_NUM);
byteswap_hsfmatrix((HsfMatrix *)((uintptr_t)fileptr + head.matrix.ofs));
byteswap_hsfmatrix((HsfMatrix32b *)((uintptr_t)fileptr + head.matrix.ofs), matrix_file);
#else
matrix_file = (HsfMatrix *)((uintptr_t)fileptr+head.matrix.ofs);
matrix_file->data = (Mtx *)((u32)fileptr+head.matrix.ofs+sizeof(HsfMatrix));
@ -1883,12 +1923,16 @@ void KillHSF(HsfData *data)
HuMemDirectFree(data->palette);
HuMemDirectFree(data->st);
HuMemDirectFree(data->vertex);
for (i = 0; i < data->cenvCnt; i++) {
HsfCenv *cenv = &data->cenv[i];
HuMemDirectFree(cenv->dualData);
HuMemDirectFree(cenv->multiData);
}
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

@ -416,12 +416,6 @@ s16 Hu3DModelLink(s16 arg0) {
ModelData* var_r31;
s16 var_r28;
s16 i;
s32 temp_r0;
s32 temp_r3;
s32 temp_r5;
s32 var_ctr;
HsfData* var_r4;
HsfData* var_r5;
temp_r30 = &Hu3DData[arg0];
var_r31 = Hu3DData;
@ -434,11 +428,11 @@ s16 Hu3DModelLink(s16 arg0) {
return -1;
}
var_r31->unk_C8 = temp_r30->hsfData;
var_r31->hsfData = HuMemDirectMallocNum(HEAP_DATA, 0x80, var_r31->unk_4C);
var_r31->unk_4C = (u32)var_r31->hsfData;
var_r31->hsfData = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfData), var_r31->unk_4C);
var_r31->unk_4C = (uintptr_t)var_r31->hsfData;
*var_r31->hsfData = *temp_r30->hsfData;
temp_r3_2 = Hu3DObjDuplicate(var_r31->hsfData, var_r31->unk_4C);
var_r31->hsfData->root = (HsfObject*)((u32)temp_r3_2 + ((u32)var_r31->hsfData->root - (u32)var_r31->hsfData->object));
var_r31->hsfData->root = (HsfObject*)((uintptr_t)temp_r3_2 + ((uintptr_t)var_r31->hsfData->root - (uintptr_t)var_r31->hsfData->object));
var_r31->hsfData->object = temp_r3_2;
var_r31->unk_48 = temp_r30->unk_48;
var_r31->attr = temp_r30->attr;

86
src/port/byteswap.cpp
View file

@ -421,15 +421,18 @@ template <typename B> void bswap(B &base, HsfBuffer32b &obj, HsfBuffer &dest)
dest.data = reinterpret_cast<void *>(static_cast<uintptr_t>(obj.data));
}
template <typename B> void bswap(B &base, HsfMatrix &obj)
template <typename B> void bswap(B &base, HsfMatrix32b &obj, HsfMatrix &dest)
{
bswap(base, obj.base_idx);
bswap(base, obj.count);
obj.data = reinterpret_cast<Mtx *>(reinterpret_cast<uintptr_t>(&obj) + 0xC); // hardcoded for 64 bit support
dest.base_idx = obj.base_idx;
dest.count = obj.count;
dest.data = reinterpret_cast<Mtx *>(&obj + 1);
for (s32 i = 0; i < obj.count; i++) {
for (s32 j = 0; j < 3; j++) {
bswap_flat(base, obj.data[i][j], 4);
bswap_flat(base, dest.data[i][j], 4);
}
}
}
@ -532,6 +535,48 @@ template <typename B> void bswap(B &base, HsfCenvSingle &obj)
bswap(base, obj.normalCnt);
}
template <typename B> void bswap(B &base, HsfCenvDualWeight &obj)
{
bswap(base, obj.weight);
bswap(base, obj.pos);
bswap(base, obj.posCnt);
bswap(base, obj.normal);
bswap(base, obj.normalCnt);
}
template <typename B> void bswap(B &base, HsfCenvDual32b &obj, HsfCenvDual &dest)
{
bswap(base, obj.target1);
bswap(base, obj.target2);
bswap(base, obj.weightCnt);
bswap(base, obj.weight);
dest.target1 = obj.target1;
dest.target2 = obj.target2;
dest.weightCnt = obj.weightCnt;
dest.weight = reinterpret_cast<HsfCenvDualWeight *>(static_cast<uintptr_t>(obj.weight));
}
template <typename B> void bswap(B &base, HsfCenvMultiWeight &obj)
{
bswap(base, obj.target);
bswap(base, obj.value);
}
template <typename B> void bswap(B &base, HsfCenvMulti32b &obj, HsfCenvMulti &dest)
{
bswap(base, obj.weightCnt);
bswap(base, obj.pos);
bswap(base, obj.posCnt);
bswap(base, obj.normal);
bswap(base, obj.normalCnt);
dest.weightCnt = obj.weightCnt;
dest.pos = obj.pos;
dest.posCnt = obj.posCnt;
dest.weight = reinterpret_cast<HsfCenvMultiWeight *>(static_cast<uintptr_t>(obj.weight));
}
template <typename B> void bswap(B &base, HsfCenv32b &obj, HsfCenv &dest)
{
bswap(base, obj.name);
@ -575,7 +620,8 @@ template <typename B> void bswap(B &base, HsfObjectData32b &obj, HsfObjectData &
bswap(base, obj.cluster);
bswap(base, obj.cenvCnt);
bswap(base, obj.cenv);
bswap_flat(base, obj.file, sizeof(obj.file) / sizeof(u32));
bswap(base, obj.vtxtop);
bswap(base, obj.normtop);
dest.parent = reinterpret_cast<struct hsf_object *>(static_cast<uintptr_t>(obj.parent));
dest.childrenCount = obj.childrenCount;
@ -598,8 +644,8 @@ template <typename B> void bswap(B &base, HsfObjectData32b &obj, HsfObjectData &
dest.cluster = reinterpret_cast<HsfCluster **>(static_cast<uintptr_t>(obj.cluster));
dest.cenvCnt = obj.cenvCnt;
dest.cenv = reinterpret_cast<HsfCenv *>(static_cast<uintptr_t>(obj.cenv));
dest.file[0] = reinterpret_cast<void *>(static_cast<uintptr_t>(obj.file[0]));
dest.file[1] = reinterpret_cast<void *>(static_cast<uintptr_t>(obj.file[1]));
dest.vtxtop = reinterpret_cast<HsfVector3f *>(static_cast<uintptr_t>(obj.vtxtop));
dest.normtop = reinterpret_cast<HsfVector3f *>(static_cast<uintptr_t>(obj.normtop));
switch (type) {
case HSF_OBJ_MESH:
@ -829,9 +875,9 @@ void byteswap_hsfbuffer(HsfBuffer32b *src, HsfBuffer *dest)
sVisitedPtrs.clear();
}
void byteswap_hsfmatrix(HsfMatrix *src)
void byteswap_hsfmatrix(HsfMatrix32b *src, HsfMatrix *dest)
{
bswap(*src, *src);
bswap(*src, *src, *dest);
sVisitedPtrs.clear();
}
@ -877,6 +923,30 @@ void byteswap_hsfcenv_single(HsfCenvSingle *src)
sVisitedPtrs.clear();
}
void byteswap_hsfcenv_dual_weight(HsfCenvDualWeight *src)
{
bswap(*src, *src);
sVisitedPtrs.clear();
}
void byteswap_hsfcenv_dual(HsfCenvDual32b *src, HsfCenvDual *dest)
{
bswap(*src, *src, *dest);
sVisitedPtrs.clear();
}
void byteswap_hsfcenv_multi_weight(HsfCenvMultiWeight *src)
{
bswap(*src, *src);
sVisitedPtrs.clear();
}
void byteswap_hsfcenv_multi(HsfCenvMulti32b *src, HsfCenvMulti *dest)
{
bswap(*src, *src, *dest);
sVisitedPtrs.clear();
}
void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest)
{
bswap(*src, *src, *dest);