From dab8e2e54b85b73de1d53a1aae112895cbc553c7 Mon Sep 17 00:00:00 2001 From: mrshigure Date: Mon, 15 Jan 2024 16:39:32 -0800 Subject: [PATCH] Matched hsfmotion --- config/GMPE01_00/symbols.txt | 2 +- configure.py | 2 +- include/game/hsfdraw.h | 33 + include/game/hsfformat.h | 28 +- include/game/hsfman.h | 72 +- include/game/hsfmotion.h | 78 ++ src/game/hsfanim.c | 1 + src/game/hsfdraw.c | 21 - src/game/hsfex.c | 3 +- src/game/hsfman.c | 10 + src/game/hsfmotion.c | 1432 ++++++++++++++++++++++++++++++++++ src/game/objmain.c | 1 + 12 files changed, 1592 insertions(+), 91 deletions(-) create mode 100644 include/game/hsfmotion.h create mode 100644 src/game/hsfmotion.c diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index 80f952f1..580ed8e9 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -6128,7 +6128,7 @@ Hu3DShadowCamBit = .sbss:0x801D3C50; // type:object size:0x2 data:2byte toonAnim = .sbss:0x801D3C54; // type:object size:0x4 data:4byte reflectMapNo = .sbss:0x801D3C58; // type:object size:0x2 data:2byte BGColor = .sbss:0x801D3C5A; // type:object size:0x4 data:byte -bitMapPtr = .sbss:0x801D3C60; // type:object size:0x8 scope:local data:4byte +bitMapPtr = .sbss:0x801D3C60; // type:object size:0x4 scope:local data:4byte metf = .sbss:0x801D3C68; // type:object size:0x1 scope:local data:byte tokenEndF = .sbss:0x801D3C6A; // type:object size:0x2 scope:local data:2byte total_copy_clks = .sbss:0x801D3C6C; // type:object size:0x4 scope:local data:4byte diff --git a/configure.py b/configure.py index f8532bf9..2e913a0a 100644 --- a/configure.py +++ b/configure.py @@ -327,7 +327,7 @@ config.libs = [ Object(Matching, "game/hsfload.c"), Object(NonMatching, "game/hsfdraw.c"), Object(Matching, "game/hsfman.c"), - Object(NonMatching, "game/hsfmotion.c"), + Object(Matching, "game/hsfmotion.c"), Object(Matching, "game/hsfanim.c"), Object(Matching, "game/hsfex.c"), Object(Matching, "game/perf.c"), diff --git a/include/game/hsfdraw.h b/include/game/hsfdraw.h index 9632e55d..7ece73ec 100755 --- a/include/game/hsfdraw.h +++ b/include/game/hsfdraw.h @@ -4,6 +4,30 @@ #include "game/hsfman.h" #include "dolphin.h" +typedef struct model_data ModelData; + +typedef struct { + /* 0x00 */ u16 unk00; + /* 0x02 */ s16 unk02; + /* 0x04 */ s16 unk04; + /* 0x06 */ char unk06[2]; + /* 0x08 */ float unk08; + /* 0x0C */ float unk0C; + /* 0x10 */ float unk10; + /* 0x14 */ float unk14; + /* 0x18 */ float unk18; + /* 0x1C */ float unk1C; + /* 0x20 */ float unk20; + /* 0x24 */ float unk24; + /* 0x28 */ float unk28; + /* 0x2C */ float unk2C; + /* 0x30 */ float unk30; + /* 0x34 */ float unk34; + /* 0x38 */ float unk38; + /* 0x3C */ HsfBitmap *unk3C; + /* 0x40 */ char unk40[4]; +} HsfdrawStruct01; // Size 0x44 + void Hu3DDrawPreInit(void); void Hu3DDraw(ModelData *arg0, Mtx arg1, Vec *arg2); s32 ObjCullCheck(HsfData *arg0, HsfObject *arg1, Mtx arg2); @@ -25,4 +49,13 @@ HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1); void Hu3DModelObjDrawInit(void); void Hu3DModelObjDraw(s16 arg0, char *arg1, Mtx arg2); +extern u32 totalPolyCnt; +extern u32 totalPolyCnted; +extern u32 totalMatCnt; +extern u32 totalMatCnted; +extern u32 totalTexCnt; +extern u32 totalTexCnted; +extern u32 totalTexCacheCnt; +extern u32 totalTexCacheCnted; + #endif diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 5eac6a3b..4a567220 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -241,7 +241,9 @@ typedef struct hsf_cluster { u32 target; }; HsfPart *part; - u8 unk10[132]; + float unk10; + float unk14[1]; // unknown array size + u8 unk18[124]; u8 adjusted; u8 unk95; u16 type; @@ -269,7 +271,7 @@ typedef struct hsf_object_data { HsfVector3f min; HsfVector3f max; float baseMorph; - float *morphWeight[33]; + float morphWeight[33]; } mesh; struct hsf_object *replica; }; @@ -339,9 +341,23 @@ typedef struct hsf_bitmap_keyframe { typedef struct hsf_track { u8 type; u8 start; - u16 target; - u16 param; - u16 channel; + 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 { @@ -352,7 +368,7 @@ typedef struct hsf_track { typedef struct hsf_motion { char *name; - u32 numTracks; + s32 numTracks; HsfTrack *track; float len; } HsfMotion; diff --git a/include/game/hsfman.h b/include/game/hsfman.h index 1a794db5..dbbd9e9c 100644 --- a/include/game/hsfman.h +++ b/include/game/hsfman.h @@ -1,15 +1,8 @@ #ifndef _GAME_HSFMAN_H #define _GAME_HSFMAN_H -#include "math.h" -#include "game/memory.h" #include "game/hsfanim.h" #include "game/hsfformat.h" -#include "game/sprite.h" -#include "game/init.h" -#include "game/data.h" -#include "game/memory.h" -#include "dolphin/gx/GXVert.h" #define Hu3DModelCreateFile(data_id) (Hu3DModelCreate(HuDataSelHeapReadNum((data_id), MEMORY_DEFAULT_NUM, HEAP_DATA))) @@ -45,9 +38,19 @@ typedef struct model_data { f32 unk_64; Point3d unk_68; f32 unk_74; - char unk_78[0x1C]; + f32 unk_78; + f32 unk_7C; + f32 unk_80; + f32 unk_84; + f32 unk_88; + f32 unk_8C; + f32 unk_90; f32 unk_94; - char unk_98[0x2C]; + f32 unk_98; + f32 unk_9C; + f32 unk_A0; + f32 unk_A4[4]; + f32 unk_B4[4]; union { HsfData *hsfData; ModelHookFunc hook; @@ -102,11 +105,6 @@ typedef struct shadow_data { Mtx unk_38; Mtx unk_68; } ShadowData; // sizeof 0x98 -typedef struct motion_data { - s16 unk_00; - s16 unk_02; - HsfData *unk_04; -} MotionData; typedef struct light_data { s16 unk_00; s16 unk_02; @@ -123,45 +121,8 @@ extern void ClusterMotionExec(ModelData*); /* extern */ extern void ClusterProc(ModelData*); /* extern */ extern void EnvelopeProc(HsfData*); /* extern */ extern void GXWaitDrawDone(); /* extern */ -extern void Hu3DAnimExec(); /* extern */ -extern void Hu3DCameraMotionExec(s16); /* extern */ -extern void Hu3DDraw(ModelData*, Mtx, Vec*); /* extern */ -extern void Hu3DDrawPost(); /* extern */ -extern void Hu3DDrawPreInit(); /* extern */ -extern void Hu3DMotionNext(s16); /* extern */ -extern void Hu3DShadowExec(); /* extern */ -extern void Hu3DSubMotionExec(s16); /* extern */ -extern void HuPerfBegin(s32); /* extern */ -extern void HuPerfEnd(s32); /* extern */ -extern void HuSprBegin(void); /* extern */ -extern void HuSprDispInit(void); /* extern */ -extern void HuSprExec(s16); /* extern */ -extern void HuSprFinish(void); /* extern */ extern void InitVtxParm(HsfData*); /* extern */ extern void ShapeProc(HsfData*); /* extern */ -extern void mtxRot(Mtx, f32, f32, f32); /* extern */ -extern void mtxScaleCat(Mtx, f32, f32, f32); /* extern */ -extern void mtxTransCat(Mtx, f32, f32, f32); -extern void Hu3DAnimInit(void); -extern void Hu3DMotionInit(void); -extern void Hu3DParManInit(void); -extern void Hu3DMotionClusterSet(s16, s16); /* extern */ -extern void Hu3DMotionExec(s16, s16, f32, s32); -extern f32 Hu3DMotionMaxTimeGet(s16); /* extern */ -extern s16 Hu3DMotionModelCreate(s16); /* extern */ -extern void Hu3DMotionShapeSet(s16, s16); /* extern */ -extern void MakeDisplayList(s16, HsfData*); /* extern */ -extern void ClusterAdjustObject(HsfData*, HsfData*); /* extern */ -extern HsfObject* Hu3DObjDuplicate(HsfData*, u32); /* extern */ -extern void Hu3DAnimModelKill(s16); /* extern */ -extern void Hu3DGLightKill(s16); /* extern */ -extern void Hu3DLLightKill(s16, s16); /* extern */ -extern s32 Hu3DMotionKill(s16); -extern void Hu3DModelKill(s16); -extern void Hu3DParManAllKill(void); -extern f32 Hu3DMotionMotionMaxTimeGet(s16); -extern void Hu3DMotionStartEndSet(s16, f32, f32); -extern void Hu3DMotionTimeSet(s16, f32); extern void GXInitSpecularDir(GXLightObj*, f32, f32, f32); void Hu3DInit(void); @@ -283,13 +244,4 @@ extern s16 Hu3DCameraNo; extern s16 Hu3DCameraBit; extern s16 Hu3DPauseF; -extern MotionData Hu3DMotion[0x100]; -extern u32 totalMatCnt; -extern u32 totalMatCnted; -extern u32 totalPolyCnt; -extern u32 totalPolyCnted; -extern u32 totalTexCacheCnt; -extern u32 totalTexCacheCnted; -extern u32 totalTexCnt; -extern u32 totalTexCnted; #endif diff --git a/include/game/hsfmotion.h b/include/game/hsfmotion.h new file mode 100644 index 00000000..826cefe8 --- /dev/null +++ b/include/game/hsfmotion.h @@ -0,0 +1,78 @@ +#ifndef _GAME_HSFMOTION_H +#define _GAME_HSFMOTION_H + +#include "dolphin.h" +#include "game/hsfformat.h" + +typedef struct motion_data { + s16 unk_00; + s16 unk_02; + HsfData *unk_04; +} MotionData; + +typedef struct { + /* 0x00 */ float unk00; + /* 0x04 */ HsfBitmap *unk04; +} UnknownHsfMotionStruct01; // Size 8 + +void Hu3DMotionInit(void); +s16 Hu3DMotionCreate(void *arg0); +s16 Hu3DMotionModelCreate(s16 arg0); +s32 Hu3DMotionKill(s16 arg0); +void Hu3DMotionAllKill(void); +void Hu3DMotionSet(s16 arg0, s16 arg1); +void Hu3DMotionOverlaySet(s16 arg0, s16 arg1); +void Hu3DMotionOverlayReset(s16 arg0); +float Hu3DMotionOverlayTimeGet(s16 arg0); +void Hu3DMotionOverlayTimeSet(s16 arg0, float arg1); +void Hu3DMotionOverlaySpeedSet(s16 arg0, float arg1); +void Hu3DMotionShiftSet(s16 arg0, s16 arg1, float arg2, float arg3, u32 arg4); +void Hu3DMotionShapeSet(s16 arg0, s16 arg1); +s16 Hu3DMotionShapeIDGet(s16 arg0); +void Hu3DMotionShapeSpeedSet(s16 arg0, float arg1); +void Hu3DMotionShapeTimeSet(s16 arg0, float arg1); +float Hu3DMotionShapeMaxTimeGet(s16 arg0); +void Hu3DMotionShapeStartEndSet(s16 arg0, float arg1, float arg2); +s16 Hu3DMotionClusterSet(s16 arg0, s16 arg1); +s16 Hu3DMotionClusterNoSet(s16 arg0, s16 arg1, s16 arg2); +void Hu3DMotionShapeReset(s16 arg0); +void Hu3DMotionClusterReset(s16 arg0, s16 arg1); +s16 Hu3DMotionIDGet(s16 arg0); +s16 Hu3DMotionShiftIDGet(s16 arg0); +void Hu3DMotionTimeSet(s16 arg0, float arg1); +float Hu3DMotionTimeGet(s16 arg0); +float Hu3DMotionShiftTimeGet(s16 arg0); +float Hu3DMotionMaxTimeGet(s16 arg0); +float Hu3DMotionShiftMaxTimeGet(s16 arg0); +void Hu3DMotionShiftStartEndSet(s16 arg0, float arg1, float arg2); +float Hu3DMotionMotionMaxTimeGet(s16 arg0); +void Hu3DMotionStartEndSet(s16 arg0, float arg1, float arg2); +s32 Hu3DMotionEndCheck(s16 arg0); +void Hu3DMotionSpeedSet(s16 arg0, float arg1); +void Hu3DMotionShiftSpeedSet(s16 arg0, float arg1); +void Hu3DMotionNoMotSet(s16 arg0, char *arg1, u32 arg2); +void Hu3DMotionNoMotReset(s16 arg0, char *arg1, u32 arg2); +void Hu3DMotionForceSet(s16 arg0, char *arg1, u32 arg2, float arg3); +void Hu3DMotionNext(s16 arg0); +void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3); +void Hu3DCameraMotionExec(s16 arg0); +void Hu3DSubMotionExec(s16 arg0); +float *GetObjTRXPtr(HsfObject *arg0, u16 arg1); +void SetObjMatMotion(s16 arg0, HsfTrack *arg1, float arg2); +void SetObjAttrMotion(s16 arg0, HsfTrack *arg1, float arg2); +void SetObjCameraMotion(s16 arg0, HsfTrack *arg1, float arg2); +void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2); +float GetCurve(HsfTrack *arg0, float arg1); +float GetConstant(s32 arg0, float *arg1, float arg2); +float GetLinear(s32 arg0, float arg1[][2], float arg2); +float GetBezier(s32 arg0, HsfTrack *arg1, float arg2); +HsfBitmap *GetBitMap(s32 arg0, UnknownHsfMotionStruct01 *arg1, float arg2); +s16 Hu3DJointMotion(s16 arg0, void *arg1); +void JointModel_Motion(s16 arg0, s16 arg1); +void Hu3DMotionCalc(s16 arg0); +s32 SearchObjectIndex(HsfData *arg0, u32 arg1); +s32 SearchAttributeIndex(HsfData *arg0, u32 arg1); + +extern MotionData Hu3DMotion[256]; + +#endif diff --git a/src/game/hsfanim.c b/src/game/hsfanim.c index 8e8ca948..3ca03d2f 100755 --- a/src/game/hsfanim.c +++ b/src/game/hsfanim.c @@ -1,5 +1,6 @@ #include "game/hsfanim.h" #include "game/hsfdraw.h" +#include "game/init.h" #include "game/memory.h" #include "game/process.h" diff --git a/src/game/hsfdraw.c b/src/game/hsfdraw.c index 93a8f6d0..5d360457 100755 --- a/src/game/hsfdraw.c +++ b/src/game/hsfdraw.c @@ -16,27 +16,6 @@ typedef struct { /* 0x3C */ Vec unk3C; } HsfdrawStruct00; // Size 0x48 -typedef struct { - /* 0x00 */ u16 unk00; - /* 0x02 */ s16 unk02; - /* 0x04 */ s16 unk04; - /* 0x06 */ char unk06[2]; - /* 0x08 */ float unk08; - /* 0x0C */ float unk0C; - /* 0x10 */ float unk10; - /* 0x14 */ float unk14; - /* 0x18 */ float unk18; - /* 0x1C */ float unk1C; - /* 0x20 */ float unk20; - /* 0x24 */ float unk24; - /* 0x28 */ float unk28; - /* 0x2C */ float unk2C; - /* 0x30 */ float unk30; - /* 0x34 */ float unk34; - /* 0x38 */ float unk38; - /* 0x3C */ HsfBitmap *unk3C; -} HsfdrawStruct01; // Size unknown - typedef struct { s32 unk00; s32 unk04; diff --git a/src/game/hsfex.c b/src/game/hsfex.c index 4b1a37c7..3ea5c340 100644 --- a/src/game/hsfex.c +++ b/src/game/hsfex.c @@ -1,5 +1,6 @@ #include "game/hsfex.h" #include "game/hsfman.h" +#include "game/hsfmotion.h" #include "math.h" @@ -13,8 +14,6 @@ typedef struct { static void SetObjCamMotion(s16 arg0, HsfTrack *arg1, float arg2, HsfexStruct02 *arg3); -float GetCurve(void*, float); - void CamMotionEx2(s16 arg0, s16 arg1, float arg2, s16 arg3) { CameraData *temp_r30; s16 i; diff --git a/src/game/hsfman.c b/src/game/hsfman.c index f7ec584a..f1554ccc 100644 --- a/src/game/hsfman.c +++ b/src/game/hsfman.c @@ -1,5 +1,15 @@ #include "game/hsfman.h" +#include "game/data.h" +#include "game/hsfdraw.h" #include "game/hsfload.h" +#include "game/hsfmotion.h" +#include "game/init.h" +#include "game/memory.h" +#include "game/perf.h" +#include "game/sprite.h" +#include "dolphin/gx/GXVert.h" + +#include "math.h" ModelData Hu3DData[0x200]; CameraData Hu3DCamera[0x10]; diff --git a/src/game/hsfmotion.c b/src/game/hsfmotion.c new file mode 100644 index 00000000..7747a612 --- /dev/null +++ b/src/game/hsfmotion.c @@ -0,0 +1,1432 @@ +#include "game/hsfmotion.h" +#include "game/hsfdraw.h" +#include "game/hsfload.h" +#include "game/hsfman.h" +#include "game/init.h" + +#include "math.h" +#include "string.h" + +float GetClusterCurve(HsfTrack*, float); +float GetClusterWeightCurve(HsfTrack*, float); +void ClusterMotionExec(ModelData*); +void ClusterProc(ModelData*); +void EnvelopeProc(HsfData*); +void InitVtxParm(HsfData*); +void ShapeProc(HsfData*); + +MotionData Hu3DMotion[256]; + +static HsfBitmap *bitMapPtr; + +void Hu3DMotionInit(void) { + MotionData *var_r31; + s16 i; + + var_r31 = (MotionData*) Hu3DData; + for (i = 0; i < 256; i++, var_r31++) { + var_r31->unk_04 = 0; + } +} + +s16 Hu3DMotionCreate(void *arg0) { + MotionData *var_r31; + s16 i; + + var_r31 = Hu3DMotion; + for (i = 0; i < 256; i++, var_r31++) { + if (var_r31->unk_04 == 0) { + break; + } + } + if (i == 256) { + OSReport("Error: Create Motion Over!\n"); + return -1; + } + var_r31->unk_04 = LoadHSF(arg0); + var_r31->unk_00 = 0; + var_r31->unk_02 = -1; + return i; +} + +s16 Hu3DMotionModelCreate(s16 arg0) { + ModelData *temp_r29 = &Hu3DData[arg0]; + MotionData *var_r31; + s16 i; + + var_r31 = Hu3DMotion; + for (i = 0; i < 256; i++, var_r31++) { + if (var_r31->unk_04 == 0) { + break; + } + } + if (i == 256) { + 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; + temp_r29->unk_20 = i; + return i; +} + +s32 Hu3DMotionKill(s16 arg0) { + ModelData *var_r30; + MotionData *temp_r31; + s16 i; + + temp_r31 = &Hu3DMotion[arg0]; + if (temp_r31->unk_04 == 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) { + break; + } + } + if (i != 512) { + return 0; + } + if (temp_r31->unk_02 == -1) { + HuMemDirectFree(temp_r31->unk_04); + } else { + Hu3DData[temp_r31->unk_02].unk_20 = -1; + } + temp_r31->unk_04 = NULL; + return 1; +} + +void Hu3DMotionAllKill(void) { + MotionData *var_r27; + s16 i; + + var_r27 = Hu3DMotion; + for (i = 0; i < 256; i++, var_r27++) { + if (var_r27->unk_04) { + Hu3DMotionKill(i); + } + } +} + +void Hu3DMotionSet(s16 arg0, s16 arg1) { + Hu3DData[arg0].unk_0C = -1; + Hu3DData[arg0].unk_08 = arg1; + Hu3DData[arg0].unk_64 = 0.0f; + Hu3DData[arg0].unk_68.y = 0.0f; + Hu3DData[arg0].unk_68.z = Hu3DMotionMaxTimeGet(arg0); +} + +void Hu3DMotionOverlaySet(s16 arg0, s16 arg1) { + Hu3DData[arg0].unk_0A = arg1; + Hu3DData[arg0].unk_74 = 0.0f; + Hu3DData[arg0].unk_78 = 1.0f; +} + +void Hu3DMotionOverlayReset(s16 arg0) { + Hu3DData[arg0].unk_0A = -1; +} + +float Hu3DMotionOverlayTimeGet(s16 arg0) { + return Hu3DData[arg0].unk_74; +} + +void Hu3DMotionOverlayTimeSet(s16 arg0, float arg1) { + Hu3DData[arg0].unk_74 = arg1; +} + +void Hu3DMotionOverlaySpeedSet(s16 arg0, float arg1) { + Hu3DData[arg0].unk_78 = arg1; +} + +void Hu3DMotionShiftSet(s16 arg0, s16 arg1, float arg2, float arg3, u32 arg4) { + ModelData *temp_r31 = &Hu3DData[arg0]; + MotionData *sp10 = &Hu3DMotion[arg1]; + s32 var_r30; + + arg4 &= ~0x40000000; + var_r30 = 0; + if (temp_r31->unk_0C != -1) { + temp_r31->unk_08 = temp_r31->unk_0C; + temp_r31->unk_64 = temp_r31->unk_84; + temp_r31->unk_68.x = temp_r31->unk_88; + temp_r31->unk_68.y = temp_r31->unk_8C; + temp_r31->unk_68.z = temp_r31->unk_90; + if (arg4 & 0x40000008) { + var_r30 |= 0x40000000 | 1; + } + if (arg4 & 0x40000010) { + var_r30 |= 0x40000000 | 2; + } + if (arg4 & 0x40000020) { + var_r30 |= 0x40000000 | 4; + } + temp_r31->motion_attr &= ~0x4000003F; + temp_r31->motion_attr |= var_r30; + temp_r31->motion_attr &= ~0x40000000; + } else { + temp_r31->motion_attr &= ~0x40000038; + } + temp_r31->unk_0C = arg1; + temp_r31->unk_84 = arg2; + temp_r31->unk_88 = 1.0f; + temp_r31->unk_7C = 0.0f; + temp_r31->unk_80 = arg3; + temp_r31->unk_8C = 0.0f; + temp_r31->unk_90 = Hu3DMotionShiftMaxTimeGet(arg0); + if (arg4 & 0x40000001) { + var_r30 |= 0x40000000 | 8; + } + if (arg4 & 0x40000002) { + var_r30 |= 0x40000000 | 0x10; + } + if (arg4 & 0x40000004) { + var_r30 |= 0x40000000 | 0x20; + } + arg4 &= ~0x40000007; + temp_r31->motion_attr |= var_r30 | arg4; + temp_r31->motion_attr &= ~0x40000000; +} + +void Hu3DMotionShapeSet(s16 arg0, s16 arg1) { + Hu3DData[arg0].unk_0E = arg1; + Hu3DData[arg0].unk_94 = 0.0f; + Hu3DData[arg0].unk_98 = 1.0f; + Hu3DData[arg0].unk_9C = 0.0f; + Hu3DData[arg0].unk_A0 = Hu3DMotionShapeMaxTimeGet(arg0); +} + +s16 Hu3DMotionShapeIDGet(s16 arg0) { + return Hu3DData[arg0].unk_0E; +} + +void Hu3DMotionShapeSpeedSet(s16 arg0, float arg1) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + temp_r31->unk_98 = arg1; +} + +void Hu3DMotionShapeTimeSet(s16 arg0, float arg1) { + Hu3DData[arg0].unk_94 = arg1; +} + +float Hu3DMotionShapeMaxTimeGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + return Hu3DMotionMotionMaxTimeGet(temp_r31->unk_0E); +} + +void Hu3DMotionShapeStartEndSet(s16 arg0, float arg1, float arg2) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + temp_r31->unk_9C = arg1; + temp_r31->unk_A0 = arg2; +} + +s16 Hu3DMotionClusterSet(s16 arg0, s16 arg1) { + ModelData *temp_r31 = &Hu3DData[arg0]; + s16 i; + + for (i = 0; i < 4; i++) { + if (temp_r31->unk_10[i] == -1) { + temp_r31->unk_10[i] = arg1; + temp_r31->unk_A4[i] = 0.0f; + temp_r31->unk_B4[i] = 1.0f; + temp_r31->cluster_attr[i] = 0; + temp_r31->attr |= 0x400; + ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].unk_04); + return i; + } + } + OSReport("Error: Cluster Entry Over\n"); + return -1; +} + +s16 Hu3DMotionClusterNoSet(s16 arg0, s16 arg1, s16 arg2) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + Hu3DMotionClusterReset(arg0, arg2); + temp_r31->unk_10[arg2] = arg1; + temp_r31->unk_A4[arg2] = 0.0f; + temp_r31->unk_B4[arg2] = 1.0f; + temp_r31->attr |= 0x400; + ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].unk_04); + return arg2; +} + +void Hu3DMotionShapeReset(s16 arg0) { + Hu3DData[arg0].unk_0E = -1; +} + +void Hu3DMotionClusterReset(s16 arg0, s16 arg1) { + ModelData *temp_r31 = &Hu3DData[arg0]; + s16 i; + + if (arg1 == -1) { + for (i = 0; i < 4; i++) { + temp_r31->unk_10[i] = -1; + } + temp_r31->attr &= ~0x400; + } else { + temp_r31->unk_10[arg1] = -1; + for (i = 0; i < 4; i++) { + if (temp_r31->unk_10[i] != -1) { + return; + } + } + temp_r31->attr &= ~0x400; + } +} + +s16 Hu3DMotionIDGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + return temp_r31->unk_08; +} + +s16 Hu3DMotionShiftIDGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + return temp_r31->unk_0C; +} + +void Hu3DMotionTimeSet(s16 arg0, float arg1) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + if (Hu3DMotionMaxTimeGet(arg0) <= arg1) { + arg1 = Hu3DMotionMaxTimeGet(arg0); + } + if (arg1 < 0.0f) { + arg1 = 0.0f; + } + temp_r31->unk_64 = arg1; + if (temp_r31->hsfData != (HsfData*) -1 && temp_r31->hsfData->cenvCnt != 0 && (temp_r31->motion_attr & 0x40000002)) { + Hu3DMotionExec(arg0, temp_r31->unk_08, arg1, 0); + if (temp_r31->unk_0C != -1) { + Hu3DSubMotionExec(arg0); + } + EnvelopeProc(temp_r31->hsfData); + } +} + +float Hu3DMotionTimeGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + return temp_r31->unk_64; +} + +float Hu3DMotionShiftTimeGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + return temp_r31->unk_84; +} + +float Hu3DMotionMaxTimeGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + MotionData *temp_r30; + HsfMotion *temp_r29; + s16 temp_r28; + + if (temp_r31->unk_08 == -1) { + return 0.0f; + } + temp_r30 = &Hu3DMotion[temp_r31->unk_08]; + temp_r29 = temp_r30->unk_04->motion; + temp_r28 = 0.0001 + temp_r29->len; + return temp_r28; +} + +float Hu3DMotionShiftMaxTimeGet(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + MotionData *temp_r30; + HsfMotion *temp_r29; + s16 temp_r28; + + if (temp_r31->unk_0C == -1) { + return 0.0f; + } + temp_r30 = &Hu3DMotion[temp_r31->unk_0C]; + temp_r29 = temp_r30->unk_04->motion; + temp_r28 = 0.0001 + temp_r29->len; + return temp_r28; +} + +void Hu3DMotionShiftStartEndSet(s16 arg0, float arg1, float arg2) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + temp_r31->unk_8C = arg1; + temp_r31->unk_90 = arg2; +} + +float Hu3DMotionMotionMaxTimeGet(s16 arg0) { + MotionData *temp_r31 = &Hu3DMotion[arg0]; + HsfMotion *temp_r30; + s16 temp_r29; + + if (temp_r31->unk_04 == 0) { + return 0.0f; + } + temp_r30 = temp_r31->unk_04->motion; + temp_r29 = 0.0001 + temp_r30->len; + return temp_r29; +} + +void Hu3DMotionStartEndSet(s16 arg0, float arg1, float arg2) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + temp_r31->unk_68.y = arg1; + temp_r31->unk_68.z = arg2; +} + +s32 Hu3DMotionEndCheck(s16 arg0) { + if (!(Hu3DData[arg0].motion_attr & 0x40000004)) { + return (Hu3DMotionMaxTimeGet(arg0) <= Hu3DMotionTimeGet(arg0)); + } else { + return (Hu3DMotionTimeGet(arg0) <= 0.0f); + } +} + +void Hu3DMotionSpeedSet(s16 arg0, float arg1) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + temp_r31->unk_68.x = arg1; +} + +void Hu3DMotionShiftSpeedSet(s16 arg0, float arg1) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + temp_r31->unk_88 = arg1; +} + +void Hu3DMotionNoMotSet(s16 arg0, char *arg1, u32 arg2) { + HsfConstData *var_r29; + HsfObject *temp_r3; + + temp_r3 = Hu3DModelObjPtrGet(arg0, arg1); + if (temp_r3->constData == 0) { + var_r29 = ObjConstantMake(temp_r3, (u32) Hu3DData[arg0].unk_48); + } else { + var_r29 = temp_r3->constData; + } + var_r29->flags |= arg2; + if (arg2 & 0x10) { + temp_r3->data.curr.pos.x = temp_r3->data.base.pos.x; + } + if (arg2 & 0x20) { + temp_r3->data.curr.pos.y = temp_r3->data.base.pos.y; + } + if (arg2 & 0x40) { + temp_r3->data.curr.pos.z = temp_r3->data.base.pos.z; + } + if (arg2 & 0x80) { + temp_r3->data.curr.rot.x = temp_r3->data.base.rot.x; + } + if (arg2 & 0x100) { + temp_r3->data.curr.rot.y = temp_r3->data.base.rot.y; + } + if (arg2 & 0x200) { + temp_r3->data.curr.rot.z = temp_r3->data.base.rot.z; + } +} + +void Hu3DMotionNoMotReset(s16 arg0, char *arg1, u32 arg2) { + HsfObject *temp_r31; + HsfConstData *temp_r30; + + temp_r31 = Hu3DModelObjPtrGet(arg0, arg1); + temp_r30 = temp_r31->constData; + temp_r30->flags &= ~arg2; +} + +void Hu3DMotionForceSet(s16 arg0, char *arg1, u32 arg2, float arg3) { + HsfConstData *var_r29; + HsfObject *temp_r3; + + temp_r3 = Hu3DModelObjPtrGet(arg0, arg1); + if (temp_r3->constData == 0) { + var_r29 = ObjConstantMake(temp_r3, (u32) Hu3DData[arg0].unk_48); + } else { + var_r29 = temp_r3->constData; + } + var_r29->flags |= arg2; + if (arg2 & 0x10) { + temp_r3->data.curr.pos.x = arg3; + } + if (arg2 & 0x20) { + temp_r3->data.curr.pos.y = arg3; + } + if (arg2 & 0x40) { + temp_r3->data.curr.pos.z = arg3; + } + if (arg2 & 0x80) { + temp_r3->data.curr.rot.x = arg3; + } + if (arg2 & 0x100) { + temp_r3->data.curr.rot.y = arg3; + } + if (arg2 & 0x200) { + temp_r3->data.curr.rot.z = arg3; + } +} + +void Hu3DMotionNext(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + HsfMotion *temp_r29; + MotionData *temp_r27; + u32 temp_r28; + s16 i; + + temp_r27 = &Hu3DMotion[temp_r31->unk_08]; + temp_r29 = temp_r27->unk_04->motion; + temp_r28 = temp_r31->motion_attr; + if (temp_r31->unk_08 != -1) { + temp_r27 = &Hu3DMotion[temp_r31->unk_08]; + if (!(temp_r28 & 0x40000002)) { + if (!(temp_r28 & 0x40000004)) { + temp_r31->unk_64 += temp_r31->unk_68.x * minimumVcountf; + } else { + temp_r31->unk_64 -= temp_r31->unk_68.x * minimumVcountf; + } + if (temp_r28 & 0x40000001) { + if (temp_r31->unk_64 < temp_r31->unk_68.y) { + temp_r31->unk_64 = temp_r31->unk_68.z - (temp_r31->unk_68.y - temp_r31->unk_64); + } else if (temp_r31->unk_64 >= temp_r31->unk_68.z) { + temp_r31->unk_64 = temp_r31->unk_68.y + (temp_r31->unk_64 - temp_r31->unk_68.z); + } + } else if (temp_r31->unk_64 < 0.0f) { + temp_r31->unk_64 = 0.0f; + } else if (temp_r31->unk_64 >= temp_r31->unk_68.z) { + temp_r31->unk_64 = temp_r31->unk_68.z; + } + } + } + if (temp_r31->unk_0A != -1) { + temp_r27 = &Hu3DMotion[temp_r31->unk_0A]; + temp_r29 = temp_r27->unk_04->motion; + if (!(temp_r28 & 0x40000400)) { + if (!(temp_r28 & 0x40000800)) { + temp_r31->unk_74 += temp_r31->unk_78 * minimumVcountf; + } else { + temp_r31->unk_74 -= temp_r31->unk_78 * minimumVcountf; + } + if (temp_r28 & 0x40000200) { + if (temp_r31->unk_74 < 0.0f) { + temp_r31->unk_74 = temp_r29->len; + } else if (temp_r31->unk_74 >= temp_r29->len) { + temp_r31->unk_74 = 0.0f; + } + } else if (temp_r31->unk_74 < 0.0f) { + temp_r31->unk_74 = 0.0f; + } else if (temp_r31->unk_74 >= temp_r29->len) { + temp_r31->unk_74 = temp_r29->len; + } + } + } + if (temp_r31->unk_0C != -1) { + temp_r31->unk_7C += minimumVcountf; + if (temp_r31->unk_7C >= temp_r31->unk_80) { + temp_r31->unk_08 = temp_r31->unk_0C; + temp_r31->unk_64 = temp_r31->unk_84; + temp_r31->unk_68.x = temp_r31->unk_88; + temp_r31->unk_68.y = temp_r31->unk_8C; + temp_r31->unk_68.z = temp_r31->unk_90; + temp_r31->unk_0C = -1; + temp_r28 = 0; + if (temp_r31->motion_attr & 0x40000008) { + temp_r28 |= 0x40000000 | 1; + } + if (temp_r31->motion_attr & 0x40000010) { + temp_r28 |= 0x40000000 | 2; + } + if (temp_r31->motion_attr & 0x40000020) { + temp_r28 |= 0x40000000 | 4; + } + temp_r31->motion_attr &= ~0x4000003F; + temp_r31->motion_attr |= temp_r28; + temp_r31->motion_attr &= ~0x40000000; + return; + } + if (!(temp_r31->motion_attr & 0x40000010)) { + temp_r27 = &Hu3DMotion[temp_r31->unk_0C]; + if (!(temp_r31->motion_attr & 0x40000020)) { + temp_r31->unk_84 += temp_r31->unk_88 * minimumVcountf; + } else { + temp_r31->unk_84 -= temp_r31->unk_88 * minimumVcountf; + } + if (temp_r31->motion_attr & 0x40000008) { + if (temp_r31->unk_84 < temp_r31->unk_8C) { + temp_r31->unk_84 = temp_r31->unk_90; + } else if (temp_r31->unk_84 >= temp_r31->unk_90) { + temp_r31->unk_84 = temp_r31->unk_8C; + } + } else if (temp_r31->unk_84 < temp_r31->unk_8C) { + temp_r31->unk_84 = temp_r31->unk_8C; + } else if (temp_r31->unk_84 >= temp_r31->unk_90) { + temp_r31->unk_84 = temp_r31->unk_90; + } + } + } + if (temp_r31->unk_0E != -1 && !(temp_r28 & 0x40000080)) { + temp_r27 = &Hu3DMotion[temp_r31->unk_0E]; + temp_r29 = temp_r27->unk_04->motion; + if (!(temp_r28 & 0x40000100)) { + temp_r31->unk_94 += temp_r31->unk_98 * minimumVcountf; + } else { + temp_r31->unk_94 -= temp_r31->unk_98 * minimumVcountf; + } + if (temp_r28 & 0x40000040) { + if (temp_r31->unk_94 < temp_r31->unk_9C) { + temp_r31->unk_94 = temp_r31->unk_A0; + } else if (temp_r31->unk_94 >= temp_r31->unk_A0) { + temp_r31->unk_94 = temp_r31->unk_9C; + } + } else if (temp_r31->unk_94 < temp_r31->unk_9C) { + temp_r31->unk_94 = temp_r31->unk_9C; + } else if (temp_r31->unk_94 >= temp_r31->unk_A0) { + temp_r31->unk_94 = temp_r31->unk_A0; + } + } + if (temp_r31->attr & 0x400) { + for (i = 0; i < 4; i++) { + if (temp_r31->unk_10[i] != -1 && !(temp_r31->cluster_attr[i] & (s32) 0xC0000002)) { + temp_r27 = &Hu3DMotion[temp_r31->unk_10[i]]; + temp_r29 = temp_r27->unk_04->motion; + if (!(temp_r31->cluster_attr[i] & (s32) 0xC0000004)) { + temp_r31->unk_A4[i] += temp_r31->unk_B4[i] * minimumVcountf; + } else { + temp_r31->unk_A4[i] -= temp_r31->unk_B4[i] * minimumVcountf; + } + if (temp_r31->cluster_attr[i] & (s32) 0xC0000001) { + if (temp_r31->unk_A4[i] < 0.0f) { + temp_r31->unk_A4[i] = temp_r29->len; + } else if (temp_r31->unk_A4[i] >= temp_r29->len) { + temp_r31->unk_A4[i] = 0.0f; + } + } else if (temp_r31->unk_A4[i] < 0.0f) { + temp_r31->unk_A4[i] = 0.0f; + } else if (temp_r31->unk_A4[i] >= temp_r29->len) { + temp_r31->unk_A4[i] = temp_r29->len; + } + } + } + } +} + +void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3) { + MotionData *sp18; + HsfData *sp14; + HsfTrack *sp10; + HsfConstData *temp_r28; + HsfData *temp_r29; + HsfMotion *temp_r21; + HsfObject *temp_r31; + HsfObject *var_r19; + HsfCluster *var_r23; + HsfTrack *var_r30; + HsfTrack *temp_r25; + HsfTrack *temp_r22; + HsfTrack *var_r26; + ModelData *temp_r27; + s16 temp_r24; + s16 var_r18; + float *temp_r17; + + temp_r27 = &Hu3DData[arg0]; + sp18 = &Hu3DMotion[arg1]; + temp_r29 = temp_r27->hsfData; + sp14 = sp18->unk_04; + temp_r21 = sp14->motion; + var_r30 = temp_r21->track; + var_r19 = temp_r29->object; + if (arg3 == 0) { + for (var_r18 = 0; var_r18 < temp_r29->objectCnt; var_r19++, var_r18++) { + temp_r31 = var_r19; + if (temp_r31->constData) { + temp_r28 = temp_r31->constData; + if (temp_r28->flags & 0x3F0) { + temp_r24 = temp_r28->flags; + if (!(temp_r24 & 0x10)) { + temp_r31->data.curr.pos.x = temp_r31->data.base.pos.x; + } + if (!(temp_r24 & 0x20)) { + temp_r31->data.curr.pos.y = temp_r31->data.base.pos.y; + } + if (!(temp_r24 & 0x40)) { + temp_r31->data.curr.pos.z = temp_r31->data.base.pos.z; + } + if (!(temp_r24 & 0x80)) { + temp_r31->data.curr.rot.x = temp_r31->data.base.rot.x; + } + if (!(temp_r24 & 0x100)) { + temp_r31->data.curr.rot.y = temp_r31->data.base.rot.y; + } + if (!(temp_r24 & 0x200)) { + temp_r31->data.curr.rot.z = temp_r31->data.base.rot.z; + } + } else { + temp_r31->data.curr = temp_r31->data.base; + } + } else { + temp_r31->data.curr = temp_r31->data.base; + } + } + } + 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); + } else if (temp_r31->type == 7) { + if (temp_r27->attr & 0x2000) { + SetObjCameraMotion(arg0, var_r30, GetCurve(var_r30, arg2)); + } + } else if (temp_r31->type == 8) { + SetObjLightMotion(arg0, var_r30, GetCurve(var_r30, arg2)); + } else if (var_r30->channel == 0x18) { + if (temp_r31->constData) { + temp_r28 = temp_r31->constData; + if (GetCurve(var_r30, arg2) == 1.0f) { + temp_r28->flags &= ~0x1000; + } else { + temp_r28->flags |= 0x1000; + } + } + } else if (var_r30->channel == 0x1A) { + if (temp_r31->constData) { + temp_r28 = temp_r31->constData; + if (GetCurve(var_r30, arg2) == 1.0f) { + temp_r28->flags &= ~0x2000; + } else { + temp_r28->flags |= 0x2000; + } + } + } else { + temp_r17 = GetObjTRXPtr(temp_r31, var_r30->channel); + if (temp_r17 != (float*) -1) { + *temp_r17 = GetCurve(var_r30, arg2); + } + } + } + break; + case 3: + temp_r25 = var_r30; + 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: + if (!(temp_r27->attr & 0x80000)) { + if (var_r30->param < temp_r29->materialCnt) { + SetObjMatMotion(arg0, var_r30, GetCurve(var_r30, arg2)); + } + } + break; + case 5: + if (!(temp_r27->attr & 0x80000)) { + var_r23 = &temp_r29->cluster[var_r30->target_s16]; + var_r23->unk10 = GetClusterCurve(var_r30, arg2); + } + break; + case 6: + if (!(temp_r27->attr & 0x80000)) { + temp_r22 = var_r30; + var_r23 = &temp_r29->cluster[temp_r22->target_s16]; + var_r23->unk14[temp_r22->unk04] = GetClusterWeightCurve(temp_r22, arg2); + } + break; + case 10: + var_r26 = var_r30; + if (var_r26->target_s16 != -1 || !(temp_r27->attr & 0x80000)) { + if (var_r26->param != -1 && var_r26->param < temp_r29->attributeCnt) { + SetObjAttrMotion(arg0, var_r26, GetCurve(var_r26, arg2)); + } + } + break; + } + } +} + +void Hu3DCameraMotionExec(s16 arg0) { + ModelData *temp_r30; + MotionData *temp_r28; + HsfData *temp_r27; + HsfMotion *temp_r29; + HsfTrack *var_r31; + 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; + if (temp_r30->attr & 0x2000) { + 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)); + } + } + } +} + +void Hu3DSubMotionExec(s16 arg0) { + ModelData *temp_r30; + MotionData *temp_r22; + HsfData *temp_r28; + HsfData *temp_r21; + HsfMotion *temp_r25; + HsfTrack *var_r29; + HsfObject *var_r23; + HsfObject *temp_r26; + float *temp_r31; + float var_f30; + float var_f31; + s16 temp_r24; + s16 var_r27; + + 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; + var_r23 = temp_r28->object; + if (temp_r30->unk_08 == -1) { + for (var_r27 = 0; var_r27 < temp_r28->objectCnt; var_r23++, var_r27++) { + temp_r26 = var_r23; + temp_r26->data.curr = temp_r26->data.base; + } + } + if (temp_r30->unk_80) { + var_f30 = temp_r30->unk_7C / temp_r30->unk_80; + } 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; + 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); + if (var_f31 < 0.0f) { + var_f31 += 360.0f; + } + if (*temp_r31 < 0.0f) { + *temp_r31 += 360.0f; + } + if (var_f31 < 180.0f) { + if (*temp_r31 > (180.0f + var_f31)) { + *temp_r31 -= 360.0f; + } + } else if (*temp_r31 < (var_f31 - 180.0f)) { + var_f31 -= 360.0f; + } + *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); + } + } + } + break; + } + } +} + +__declspec(weak) float *GetObjTRXPtr(HsfObject *arg0, u16 arg1) { + HsfConstData *temp_r31 = arg0->constData; + + switch (arg1) { + case 8: + if (temp_r31 && (temp_r31->flags & 0x10)) { + return (float*) -1; + } + return &arg0->data.curr.pos.x; + case 9: + if (temp_r31 && (temp_r31->flags & 0x20)) { + return (float*) -1; + } + return &arg0->data.curr.pos.y; + case 10: + if (temp_r31 && (temp_r31->flags & 0x40)) { + return (float*) -1; + } + return &arg0->data.curr.pos.z; + case 28: + if (temp_r31 && (temp_r31->flags & 0x80)) { + return (float*) -1; + } + return &arg0->data.curr.rot.x; + case 29: + if (temp_r31 && (temp_r31->flags & 0x100)) { + return (float*) -1; + } + return &arg0->data.curr.rot.y; + case 30: + if (temp_r31 && (temp_r31->flags & 0x200)) { + return (float*) -1; + } + return &arg0->data.curr.rot.z; + case 31: + return &arg0->data.curr.scale.x; + case 32: + return &arg0->data.curr.scale.y; + case 33: + return &arg0->data.curr.scale.z; + default: + return (float*) -1; + } +} + +void SetObjMatMotion(s16 arg0, HsfTrack *arg1, float arg2) { + HsfMaterial *temp_r31; + HsfData *temp_r29; + ModelData *temp_r30; + float var_f31; + + temp_r30 = &Hu3DData[arg0]; + temp_r29 = temp_r30->hsfData; + temp_r31 = &temp_r29->material[arg1->param]; + var_f31 = arg2; + if (arg2 > 1.0f) { + var_f31 = 1.0f; + } else if (arg2 < 0.0f) { + var_f31 = 0.0f; + } + switch (arg1->channel) { + case 0: + temp_r31->litColor[0] = var_f31 * 255.0f; + break; + case 1: + temp_r31->litColor[1] = var_f31 * 255.0f; + break; + case 2: + temp_r31->litColor[2] = var_f31 * 255.0f; + break; + case 0x31: + temp_r31->color[0] = var_f31 * 255.0f; + break; + case 0x32: + temp_r31->color[1] = var_f31 * 255.0f; + break; + case 0x33: + temp_r31->color[2] = var_f31 * 255.0f; + break; + case 0x34: + temp_r31->shadowColor[0] = var_f31 * 255.0f; + break; + case 0x35: + temp_r31->shadowColor[1] = var_f31 * 255.0f; + break; + case 0x36: + temp_r31->shadowColor[2] = var_f31 * 255.0f; + break; + case 0x39: + if (!(temp_r30->attr & 0x40000)) { + temp_r31->invAlpha = var_f31; + } + break; + case 0x3C: + temp_r31->refAlpha = var_f31; + break; + } +} + +void SetObjAttrMotion(s16 arg0, HsfTrack *arg1, float arg2) { + ModelData *temp_r28; + HsfData *temp_r27; + HsfAttribute *temp_r30; + HsfdrawStruct01 *var_r31; + float var_f30; + + temp_r28 = &Hu3DData[arg0]; + temp_r27 = temp_r28->hsfData; + temp_r30 = &temp_r27->attribute[arg1->param]; + var_f30 = arg2; + if (arg2 > 1.0f) { + var_f30 = 1.0f; + } else if (arg2 < 0.0f) { + var_f30 = 0.0f; + } + switch (arg1->channel) { + case 8: + case 9: + case 0xA: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + case 0x20: + case 0x21: + case 0x43: + if (temp_r30->unk04 == 0) { + var_r31 = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfdrawStruct01), (u32) Hu3DData[arg0].unk_48); + temp_r30->unk04 = var_r31; + var_r31->unk00 = 0; + var_r31->unk08 = var_r31->unk0C = var_r31->unk10 = 0.0f; + var_r31->unk14 = var_r31->unk18 = var_r31->unk1C = 0.0f; + var_r31->unk20 = var_r31->unk24 = var_r31->unk28 = 1.0f; + } else { + var_r31 = temp_r30->unk04; + } + if (arg1->channel != 0x43) { + var_r31->unk00 |= 4; + } else { + var_r31->unk00 |= 8; + } + break; + } + switch (arg1->channel) { + case 8: + var_r31->unk08 = arg2; + break; + case 9: + var_r31->unk0C = arg2; + break; + case 10: + var_r31->unk10 = arg2; + break; + case 28: + var_r31->unk14 = arg2; + break; + case 29: + var_r31->unk18 = arg2; + break; + case 30: + var_r31->unk1C = arg2; + break; + case 31: + var_r31->unk20 = arg2; + break; + case 32: + var_r31->unk24 = arg2; + break; + case 33: + var_r31->unk28 = arg2; + break; + case 64: + temp_r30->unk20 = var_f30; + break; + case 62: + temp_r30->unk0C = var_f30; + break; + case 63: + temp_r30->unk14 = arg2; + break; + case 67: + var_r31->unk3C = bitMapPtr; + break; + } +} + +void SetObjCameraMotion(s16 arg0, HsfTrack *arg1, float arg2) { + ModelData *temp_r29; + Vec sp18; + Vec spC; + float var_f31; + float var_f30; + s16 var_r30; + s16 temp_r28; + s16 i; + + temp_r29 = &Hu3DData[arg0]; + temp_r28 = temp_r29->unk_01; + if (temp_r28 != 0) { + var_f31 = arg2; + if (arg2 > 1.0f) { + var_f31 = 1.0f; + } else if (arg2 < 0.0f) { + var_f31 = 0.0f; + } + switch (arg1->channel) { + case 8: + var_f30 = temp_r29->scale.x * (arg2 + temp_r29->pos.x); + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].pos.x = var_f30; + } + } + break; + case 9: + var_f30 = temp_r29->scale.y * (arg2 + temp_r29->pos.y); + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].pos.y = var_f30; + } + } + break; + case 10: + var_f30 = temp_r29->scale.z * (arg2 + temp_r29->pos.z); + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].pos.z = var_f30; + } + } + break; + case 11: + var_f30 = temp_r29->scale.x * (arg2 + temp_r29->pos.x); + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].target.x = var_f30; + } + } + break; + case 12: + var_f30 = temp_r29->scale.y * (arg2 + temp_r29->pos.y); + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].target.y = var_f30; + } + } + break; + case 13: + var_f30 = temp_r29->scale.z * (arg2 + temp_r29->pos.z); + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].target.z = var_f30; + } + } + break; + case 14: + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + PSVECSubtract(&Hu3DCamera[i].pos, &Hu3DCamera[i].target, &spC); + PSVECNormalize(&spC, &spC); + sp18.x = spC.x * spC.y * (1.0 - cos(M_PI * arg2 / 180.0)) - spC.z * sin(M_PI * arg2 / 180.0); + sp18.y = spC.y * spC.y + (1.0f - spC.y * spC.y) * cos(M_PI * arg2 / 180.0); + sp18.z = spC.y * spC.z * (1.0 - cos(M_PI * arg2 / 180.0)) + spC.x * sin(M_PI * arg2 / 180.0); + PSVECNormalize(&sp18, &Hu3DCamera[i].up); + Hu3DCamera[i].aspect_dupe = arg2; + } + } + break; + case 15: + for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { + if (var_r30 & temp_r28) { + Hu3DCamera[i].fov = arg2; + } + } + break; + } + } +} + +void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2) { + s16 var_r29; + ModelData *temp_r30; + HsfData *temp_r28; + HsfObject *var_r26; + HsfObject *var_r24; + LightData *temp_r31; + float var_f30; + s16 i; + + temp_r30 = &Hu3DData[arg0]; + temp_r28 = temp_r30->hsfData; + 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 (i != arg1->target) { + var_r29++; + } else { + break; + } + } + } + if (i != temp_r28->objectCnt) { + temp_r31 = &Hu3DGlobalLight[temp_r30->unk_28[var_r29]]; + var_f30 = arg2; + if (arg2 > 1.0f) { + var_f30 = 1.0f; + } else if (arg2 < 0.0f) { + var_f30 = 0.0f; + } + switch (arg1->channel) { + case 8: + temp_r31->unk_1C.x = arg2; + break; + case 9: + temp_r31->unk_1C.y = arg2; + break; + case 10: + temp_r31->unk_1C.z = arg2; + break; + case 11: + temp_r31->unk_34.x = arg2; + Hu3DGLightPosAimSetV(temp_r30->unk_28[var_r29], &temp_r31->unk_1C, &temp_r31->unk_34); + break; + case 12: + temp_r31->unk_34.y = arg2; + Hu3DGLightPosAimSetV(temp_r30->unk_28[var_r29], &temp_r31->unk_1C, &temp_r31->unk_34); + break; + case 13: + temp_r31->unk_34.z = arg2; + Hu3DGLightPosAimSetV(temp_r30->unk_28[var_r29], &temp_r31->unk_1C, &temp_r31->unk_34); + break; + } + } +} + +float GetCurve(HsfTrack *arg0, 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); + break; + case 4: + var_r30 = &arg0->value; + return *var_r30; + case 0: + return GetConstant(arg0->numKeyframes, arg0->data, arg1); + } + return 0.0f; +} + +float GetConstant(s32 arg0, float *arg1, float arg2) { + float *var_r31; + s16 i; + + var_r31 = arg1; + if (arg2 == 0.0f || arg0 == 1) { + return arg1[1]; + } + for (i = 0; i < arg0; i++, var_r31 += 2) { + if (arg2 < var_r31[0]) { + return var_r31[-1]; + } + } + return var_r31[-1]; +} + +float GetLinear(s32 arg0, float arg1[][2], float arg2) { + float var_f31; + float var_f30; + s16 temp_r30; + s16 var_r31; + + if (arg2 == 0.0f || arg0 == 1) { + return arg1[0][1]; + } + for (var_r31 = 0; var_r31 < arg0; var_r31++) { + if (arg2 < arg1[var_r31][0]) { + temp_r30 = var_r31 - 1; + var_f30 = arg1[var_r31][0] - arg1[temp_r30][0]; + var_f31 = arg1[temp_r30][1] + (arg2 - arg1[temp_r30][0]) * ((arg1[var_r31][1] - arg1[temp_r30][1]) / var_f30); + return var_f31; + } + } + return arg1[arg0 - 1][1]; +} + +__declspec(weak) float GetBezier(s32 arg0, HsfTrack *arg1, float arg2) { + float temp_f24; + float temp_f29; + float temp_f28; + float temp_f27; + float temp_f26; + float temp_f25; + float temp_f30; + float temp_f31; + float (*var_r31)[4]; + float (*var_r29)[4]; + s32 i; + + var_r31 = arg1->data; + if (arg2 == 0.0f || arg0 == 1) { + return var_r31[0][1]; + } + i = -1; + if (arg1->start == 0 && arg2 < var_r31[0][0]) { + i = 0; + } + if (i == -1) { + var_r31 = (float(*)[4]) arg1->data + arg1->start; + var_r29 = var_r31 - 1; + for (i = arg1->start; i < arg0; i++, var_r31++) { + if (arg2 >= var_r29[0][0] && arg2 < var_r31[0][0]) { + break; + } + var_r29 = var_r31; + } + if (i >= arg0) { + var_r31 = arg1->data; + for (i = 0; i < arg0; i++, var_r31++) { + if (arg2 < var_r31[0][0]) { + break; + } + } + } + } + arg1->start = i; + if (i == arg0) { + return var_r31[-1][1]; + } + temp_f24 = var_r31[0][0]; + var_r31--; + temp_f29 = var_r31[0][0]; + temp_f31 = (arg2 - temp_f29) / (temp_f24 - temp_f29); + temp_f30 = temp_f31 * temp_f31; + temp_f28 = 2.0f * temp_f30; + temp_f27 = 3.0f * temp_f30; + temp_f26 = temp_f31 * temp_f30; + temp_f25 = temp_f31 * temp_f28; + return var_r31[0][1] * (temp_f25 - temp_f27 + 1.0f) + + var_r31[1][1] * (-temp_f25 + temp_f27) + + var_r31[0][2] * (temp_f26 - temp_f28 + temp_f31) + + var_r31[1][3] * (temp_f26 - temp_f30); +} + +HsfBitmap *GetBitMap(s32 arg0, UnknownHsfMotionStruct01 *arg1, float arg2) { + s16 var_r31; + + if (arg2 == 0.0f || arg0 == 1) { + return arg1->unk04; + } + for (var_r31 = 0; var_r31 < arg0; var_r31++, arg1++) { + if (arg2 < arg1->unk00 * 60.0f) { + break; + } + } + return arg1[-1].unk04; +} + +s16 Hu3DJointMotion(s16 arg0, void *arg1) { + s16 var_r29; + + var_r29 = Hu3DMotionCreate(arg1); + JointModel_Motion(arg0, var_r29); + return var_r29; +} + +void JointModel_Motion(s16 arg0, s16 arg1) { + ModelData *temp_r24; + MotionData *temp_r23; + HsfData *temp_r26; + HsfData *temp_r22; + HsfMotion *temp_r29; + HsfTrack *var_r30; + HsfTrack *var_r28; + HsfTrack *var_r27; + HsfTrack *var_r31; + s32 temp_r21; + s32 i; + + 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; + var_r28->target = SearchObjectIndex(temp_r26, var_r28->target); + break; + case 3: + var_r27 = var_r30; + var_r27->target = SearchObjectIndex(temp_r26, var_r27->target); + break; + case 10: + var_r31 = var_r30; + if (var_r31->param == -1) { + temp_r21 = SearchAttributeIndex(temp_r26, var_r31->target_s16); + if (temp_r21 != -1) { + var_r31->param = temp_r21; + } else { + var_r31->param = -1; + } + } + break; + } + } +} + +void Hu3DMotionCalc(s16 arg0) { + ModelData *temp_r31 = &Hu3DData[arg0]; + + if ((temp_r31->attr & 1) || (temp_r31->attr & 0x8000)) { + return; + } + if (temp_r31->unk_08 != -1) { + Hu3DMotionExec(arg0, temp_r31->unk_08, temp_r31->unk_64, 0); + } + if (temp_r31->unk_0C != -1) { + Hu3DSubMotionExec(arg0); + } + if (temp_r31->unk_0A != -1) { + Hu3DMotionExec(arg0, temp_r31->unk_0A, temp_r31->unk_74, 1); + } + if (temp_r31->attr & 0x400) { + ClusterMotionExec(temp_r31); + } + if (temp_r31->unk_0E != -1) { + if (temp_r31->unk_08 == -1) { + Hu3DMotionExec(arg0, temp_r31->unk_0E, temp_r31->unk_94, 0); + } else { + Hu3DMotionExec(arg0, temp_r31->unk_0E, temp_r31->unk_94, 1); + } + } + if (!(temp_r31->attr & 0x90) || !(temp_r31->motion_attr & 0x40000002)) { + InitVtxParm(temp_r31->hsfData); + if (temp_r31->unk_0E != -1) { + ShapeProc(temp_r31->hsfData); + } + if (temp_r31->attr & 0x400) { + ClusterProc(temp_r31); + } + if (temp_r31->hsfData->cenvCnt != 0) { + EnvelopeProc(temp_r31->hsfData); + } + PPCSync(); + } + temp_r31->attr |= 0x800; +} + +s32 SearchObjectIndex(HsfData *arg0, u32 arg1) { + s32 i; + char *temp_r28; + HsfObject *var_r30; + + var_r30 = arg0->object; + temp_r28 = SetName(&arg1); + for (i = 0; i < arg0->objectCnt; i++, var_r30++) { + if (CmpObjectName(var_r30->name, temp_r28) == 0) { + return i; + } + } + return -1; +} + +s32 SearchAttributeIndex(HsfData *arg0, u32 arg1) { + HsfAttribute *var_r31; + size_t temp_r28; + char *temp_r27; + s32 i; + + var_r31 = arg0->attribute; + temp_r27 = SetName(&arg1); + for (i = 0; i < arg0->attributeCnt; i++, var_r31++) { + if (var_r31->name) { + temp_r28 = strlen(var_r31->name); + if (strncmp(var_r31->name, temp_r27, temp_r28) == 0) { + return i; + } + } + } + return -1; +} diff --git a/src/game/objmain.c b/src/game/objmain.c index f253bf13..f1ab7da8 100644 --- a/src/game/objmain.c +++ b/src/game/objmain.c @@ -1,4 +1,5 @@ #include "game/audio.h" +#include "game/hsfdraw.h" #include "game/hsfman.h" #include "game/printfunc.h" #include "game/object.h"