From a12b53f9fb7fabf02dc4e26b7622be29ff78b7ba Mon Sep 17 00:00:00 2001 From: CreateSource Date: Tue, 12 Dec 2023 23:15:29 -0500 Subject: [PATCH 1/3] steady progress on all fronts completed .bss new functions: Hu3DModelHiliteMapSet to Hu3DLLightSpotSet --- config/GMPE01_00/symbols.txt | 1 + include/functions.h | 6 +- include/game/hsfformat.h | 29 +- include/game/hsfman.h | 97 +++- include/math.h | 4 +- include/variables.h | 2 - src/game/hsfman.c | 889 +++++++++++++++++++++++++++++++---- 7 files changed, 902 insertions(+), 126 deletions(-) diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index de746dd1..cfcd0172 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -5426,6 +5426,7 @@ Hu3DCameraMtx = .bss:0x8018C89C; // type:object size:0x30 Hu3DCameraMtxXPose = .bss:0x8018C8CC; // type:object size:0x30 Hu3DGlobalLight = .bss:0x8018C8FC; // type:object size:0x220 data:2byte Hu3DLocalLight = .bss:0x8018CB1C; // type:object size:0x8B4 data:2byte +lbl_8018D39C = .bss:0x8018D39C; // type:object size:0x48 Hu3DMotion = .bss:0x8018D3D0; // type:object size:0x800 data:2byte Hu3DTexAnimData = .bss:0x8018DBD0; // type:object size:0x1400 data:2byte Hu3DTexScrData = .bss:0x8018EFD0; // type:object size:0x6C0 data:2byte diff --git a/include/functions.h b/include/functions.h index a906f8c5..b9decdb0 100644 --- a/include/functions.h +++ b/include/functions.h @@ -8,9 +8,9 @@ void Hu3DLayerHookSet(short layer, void (*func)(short layer)); void Hu3D2Dto3D(Vec*, s32, Vec*); void Hu3DModelLightInfoSet(s32, s32); void Hu3DBGColorSet(u8, u8, u8); -void Hu3DCameraCreate(s16); -void Hu3DCameraPerspectiveSet(s16, f32, f32, f32, f32); -void Hu3DCameraViewportSet(s16, f32, f32, f32, f32, f32, f32); +void Hu3DCameraCreate(s32); +void Hu3DCameraPerspectiveSet(s32, f32, f32, f32, f32); +void Hu3DCameraViewportSet(s32, f32, f32, f32, f32, f32, f32); void HuAudFadeOut(int arg0); void WipeCreate(char dir, char type, short duration); diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 5ba913f8..e81d5c84 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -2,6 +2,7 @@ #define _GAME_HSFFORMAT_H #include "dolphin.h" +#include "game/hsfanim.h" #define HSF_OBJ_NULL1 0 #define HSF_OBJ_REPLICA 1 @@ -151,13 +152,15 @@ typedef struct hsf_face { typedef struct hsf_const_data { u32 flags; - u8 unk4[64]; + s16 hook; + u8 unk6[0x3A]; + AnimData *hilite_map; } HsfConstData; typedef struct hsf_transform { - HsfVector3f pos; - HsfVector3f rot; - HsfVector3f scale; + Vec pos; + Vec rot; + Vec scale; } HsfTransform; typedef struct hsf_cenv_single { @@ -273,12 +276,24 @@ typedef struct hsf_object_data { void *file[2]; } HsfObjectData; +typedef struct hsf_camera { + HsfVector3f target; + HsfVector3f pos; + float aspect_dupe; + float fov; + float near; + float far; +} HsfCamera; + typedef struct hsf_object { char *name; - s32 type; + u32 type; HsfConstData *constData; u32 flags; - HsfObjectData data; + union { + HsfObjectData data; + HsfCamera camera; + }; } HsfObject; typedef struct hsf_skeleton { @@ -370,4 +385,4 @@ typedef struct hsf_data { s16 matrixCnt; } HsfData; -#endif \ No newline at end of file +#endif diff --git a/include/game/hsfman.h b/include/game/hsfman.h index a49204cb..e4eaab3a 100644 --- a/include/game/hsfman.h +++ b/include/game/hsfman.h @@ -2,15 +2,17 @@ #define _GAME_HSFMAN_H #include "common.h" +#include "math.h" #include "game/memory.h" #include "game/hsfanim.h" #include "game/hsfformat.h" #include "game/sprite.h" +#include "game/init.h" typedef struct model_data { u8 unk_00; u8 unk_01; - s8 unk_02; + u8 unk_02; s8 unk_03; s8 unk_04; s8 unk_05; @@ -45,38 +47,58 @@ typedef struct model_data { Vec scale; Mtx unk_F0; ParticleData *unk_120; -} ModelData; - -typedef struct ThreeDCameraStruct { - f32 unk_00; - f32 start; - f32 end; - char unk_04[0x4C]; -} ThreeDCameraStruct; +} ModelData; // sizeof 0x124 +typedef struct camera_data { + f32 fov; + f32 near; + f32 far; + f32 aspect; + f32 aspect_dupe; + Vec pos; + Vec up; + Vec target; + s16 scissor_x; + s16 scissor_y; + s16 scissor_w; + s16 scissor_h; + f32 viewport_x; + f32 viewport_y; + f32 viewport_w; + f32 viewport_h; + f32 near_z; + f32 far_z; +} CameraData; // sizeof 0x58 typedef struct ThreeDProjectionStruct { - s8 unk_00; + u8 unk_00; char unk_01[0x3]; - AnimData *unk_04; - char unk_08[0xC]; + void *unk_04; + Vec unk_08; Point3d unk_14; Point3d unk_20; Vec unk_2C; Mtx unk_38; - char unk_68[0x30]; -} ThreeDProjectionStruct; + Mtx unk_68; +} ThreeDProjectionStruct; // sizeof 0x98 typedef struct shadow_data { char unk_00[0x2]; u16 unk_02; void*unk_04; char unk_08[0x90]; -} ShadowData; +} ShadowData; // sizeof 0x98 typedef struct motion_data { s16 unk_00; s16 unk_02; HsfData *unk_04; } MotionData; typedef struct light_data { - char unk_00[0x44]; + s16 unk_00; + s16 unk_02; + f32 unk_04; + char unk_08[0x14]; + Vec unk_1C; + Vec unk_28; + Vec unk_34; + GXColor color; } LightData; void ClusterMotionExec(ModelData*); /* extern */ @@ -85,7 +107,6 @@ void EnvelopeProc(HsfData*); /* extern */ void GXWaitDrawDone(); /* extern */ void Hu3DAnimExec(); /* extern */ void Hu3DCameraMotionExec(s16); /* extern */ -void Hu3DCameraSet(s16, void*); /* extern */ void Hu3DDraw(ModelData*, f32*, f32*); /* extern */ void Hu3DDrawPost(); /* extern */ void Hu3DDrawPreInit(); /* extern */ @@ -105,7 +126,6 @@ void mtxScaleCat(Mtx, f32, f32, f32); /* extern */ void mtxTransCat(Mtx, f32, f32, f32); void Hu3DAnimInit(void); void Hu3DFogClear(void); -void Hu3DLighInit(void); void Hu3DMotionInit(void); void Hu3DParManInit(void); void Hu3DFogSet(f32, f32, u8, u8, u8); /* extern */ @@ -125,6 +145,9 @@ s32 Hu3DMotionKill(s16); void Hu3DModelKill(s16); void Hu3DParManAllKill(void); s32 MakeObjectName(s32); +f32 Hu3DMotionMotionMaxTimeGet(s16); +void Hu3DMotionStartEndSet(s16, f32, f32); +void Hu3DMotionTimeSet(s16, f32); void Hu3DInit(void); void Hu3DPreProc(void); @@ -153,6 +176,41 @@ void Hu3DModelClusterAttrReset(s16, s16, s32); void Hu3DModelCameraSet(s16, u16); void Hu3DModelLayerSet(s16, s16); HsfObject* Hu3DModelObjPtrGet(s16, s32); +void Hu3DModelTPLvlSet(s16, f32); +void Hu3DModelHiliteMapSet(s16, AnimData*); +void Hu3DModelShadowSet(s16); +void Hu3DModelShadowReset(s16); +void Hu3DModelShadowDispOn(s16); +void Hu3DModelShadowDispOff(s16); +void Hu3DModelShadowMapSet(s16); +void Hu3DModelShadowMapObjSet(s16, s32); +void Hu3DModelAmbSet(s16, f32, f32, f32); +void Hu3DModelHookSet(s16, s32, s16); +void Hu3DModelHookReset(s16); +void Hu3DModelHookObjReset(s16, s32); +void Hu3DModelProjectionSet(s16, s16); +void Hu3DModelProjectionReset(s16, s16); +void Hu3DModelHiliteTypeSet(s16, s16); +void Hu3DModelReflectTypeSet(s16, s16); +void Hu3DCameraCreate(s32); +void Hu3DCameraPerspectiveSet(s32, f32, f32, f32, f32); +void Hu3DCameraViewportSet(s32, f32, f32, f32, f32, f32, f32); +void Hu3DCameraScissorSet(s32, s32, s32, s32, s32); +void Hu3DCameraPosSet(s32, f32, f32, f32, f32, f32, f32, f32, f32, f32); +void Hu3DCameraPosSetV(s32, Vec, Vec, Vec); +void Hu3DCameraKill(s32); +void Hu3DCameraAllKill(void); +void Hu3DCameraSet(s32, Mtx); +BOOL Hu3DModelCameraInfoSet(s16, u16); +s16 Hu3DModelCameraCreate(s16, u16); +void Hu3DCameraMotionOn(s16, s8); +void Hu3DCameraMotionStart(s16, u16); +void Hu3DCameraMotionOff(s16); +void Hu3DLighInit(void); +void Hu3DGLightCreate(f32, f32, f32, f32, f32, f32, u8, u8, u8); +s16 Hu3DGLightCreateV(Vec*, Vec*, GXColor*); +void Hu3DLLightCreate(s16, f32, f32, f32, f32, f32, f32, u8, u8, u8); +s16 Hu3DLLightCreateV(s16, Vec*, Vec*, GXColor*); //... void Hu3DShadowSizeSet(u16); void Hu3DProjectionKill(s16); @@ -161,9 +219,6 @@ void Hu3DProjectionTPLvlSet(s16, f32); void Hu3DMipMapSet(char*, s16, s32, f32); extern MotionData Hu3DMotion[0x100]; -extern f32 lbl_801D4AB0; -extern f32 lbl_801D4AB4; -extern f32 lbl_801D4AB8; extern f32 lbl_801D4AFC; extern GXColor lbl_801D6BE0; extern u32 totalMatCnt; diff --git a/include/math.h b/include/math.h index 95c77704..fb241e22 100644 --- a/include/math.h +++ b/include/math.h @@ -1,6 +1,8 @@ #ifndef _MATH_H #define _MATH_H +#define M_PI 3.141592653589793 + extern inline float sqrtf(float x) { static const double _half=.5; @@ -40,4 +42,4 @@ float acosf(float x); #define abs(x) __abs(x) -#endif \ No newline at end of file +#endif diff --git a/include/variables.h b/include/variables.h index 00a33d6b..055f334e 100644 --- a/include/variables.h +++ b/include/variables.h @@ -4,8 +4,6 @@ #include "dolphin.h" #include "common_structs.h" -#define M_PI 3.141592653589793 - extern u16 HuPadBtnDown[4]; extern u8 HuPadDStk[4]; diff --git a/src/game/hsfman.c b/src/game/hsfman.c index cd97c667..b60e1205 100644 --- a/src/game/hsfman.c +++ b/src/game/hsfman.c @@ -1,7 +1,7 @@ #include "game/hsfman.h" ModelData Hu3DData[0x200]; -ThreeDCameraStruct Hu3DCamera[0x10]; +CameraData Hu3DCamera[0x10]; s16 layerNum[8]; void (*layerHook[8])(s16); AnimData *reflectAnim[5]; @@ -10,9 +10,10 @@ ThreeDProjectionStruct Hu3DProjection[4]; ShadowData Hu3DShadowData; HsfScene FogData; Mtx Hu3DCameraMtx; -LightData Hu3DGlobalLight[0x8]; Mtx Hu3DCameraMtxXPose; +LightData Hu3DGlobalLight[0x8]; LightData Hu3DLocalLight[0x20]; +Mtx lbl_8018D39C; GXColor BGColor; s16 reflectMapNo; AnimData *toonAnim; @@ -24,7 +25,7 @@ s16 Hu3DCameraNo; s16 Hu3DCameraBit; HsfData* Hu3DMallocNo; s16 Hu3DPauseF; -s16 Hu3DCameraExistF; +u16 Hu3DCameraExistF; u16 NoSyncF; s32 modelKillAllF; @@ -42,7 +43,7 @@ s32 modelKillAllF; void Hu3DInit(void) { ModelData* data; - ThreeDCameraStruct* camera; + CameraData* camera; s16 i; data = Hu3DData; @@ -51,7 +52,7 @@ void Hu3DInit(void) { } camera = Hu3DCamera; for (i = 0; i < 0x10; i++, camera++) { - camera->unk_00 = lbl_801D4AB0; + camera->fov = -1.0f; } Hu3DMotionInit(); Hu3DLighInit(); @@ -89,20 +90,15 @@ void Hu3DInit(void) { } void Hu3DPreProc(void) { - u8 spB; - u8 spA; - u8 sp9; - GXColor sp8; - ModelData *var_r31; - s16 var_r30; + ModelData *data; + s16 i; GXSetCopyClear(BGColor, 0xFFFFFF); - var_r31 = &Hu3DData[0]; - for (var_r30 = 0; var_r30 < 0x200; var_r31++) { - if (var_r31->hsfData != 0) { - var_r31->attr &= 0xFFFFF7FF; + data = &Hu3DData[0]; + for (i = 0; i < 0x200; i++, data++) { + if (data->hsfData != 0) { + data->attr &= ~0x800; } - var_r30++; } totalPolyCnted = totalPolyCnt; totalMatCnted = totalMatCnt; @@ -112,11 +108,9 @@ void Hu3DPreProc(void) { } void Hu3DExec(void) { - GXColor spC; - GXColor sp8; - ThreeDCameraStruct* var_r27; - ModelData* var_r30; - ModelData* var_r30_2; + GXColor unusedColor; + CameraData* camera; + ModelData* data; s16 temp_r22; s16 var_r23; s16 var_r25; @@ -128,15 +122,15 @@ void Hu3DExec(void) { Mtx sp10; ThreeDProjectionStruct* var_r26; - spC = lbl_801D6BE0; + unusedColor = lbl_801D6BE0; HuPerfBegin(3); GXSetCurrentMtx(0U); - var_r27 = Hu3DCamera; + camera = Hu3DCamera; shadowModelDrawF = 0; HuSprBegin(); var_r24 = 0; - for (Hu3DCameraNo = 0; Hu3DCameraNo < 0x10; Hu3DCameraNo++, var_r27++) { - if (lbl_801D4AB0 != var_r27->unk_00) { + for (Hu3DCameraNo = 0; Hu3DCameraNo < 0x10; Hu3DCameraNo++, camera++) { + if (-1.0f != camera->fov) { GXInvalidateVtxCache(); temp_r22 = (s16) (1 << Hu3DCameraNo); Hu3DCameraBit = temp_r22; @@ -163,7 +157,7 @@ void Hu3DExec(void) { HuSprExec(0x7F); } if (FogData.fogType != GX_FOG_NONE) { - GXSetFog(FogData.fogType, FogData.start, FogData.end, var_r27->start, var_r27->end, FogData.color); + GXSetFog(FogData.fogType, FogData.start, FogData.end, camera->near, camera->far, FogData.color); } for (j = 0; j < 8; j++) { if (layerHook[j] != 0) { @@ -176,72 +170,72 @@ void Hu3DExec(void) { Hu3DDrawPreInit(); Hu3DCameraSet(Hu3DCameraNo, Hu3DCameraMtx); PSMTXInvXpose(Hu3DCameraMtx, Hu3DCameraMtxXPose); - var_r30 = Hu3DData; - for (i = 0, var_r23 = i; i < 0x200; i++, var_r30++) { - if (var_r30->hsfData != 0) { - if ((var_r30->attr & 0x10000) != 0) { + data = Hu3DData; + for (i = 0, var_r23 = i; i < 0x200; i++, data++) { + if (data->hsfData != 0) { + if ((data->attr & 0x10000) != 0) { Hu3DCameraMotionExec(i); } else { - if ((var_r30->attr & 0x2001) == 0x2001 && var_r30->unk_08 != -1) { - Hu3DMotionExec(i, var_r30->unk_08, var_r30->unk_64, 0); + if ((data->attr & 0x2001) == 0x2001 && data->unk_08 != -1) { + Hu3DMotionExec(i, data->unk_08, data->unk_64, 0); } - if ((var_r30->attr & 9) == 0 && (var_r30->camera & temp_r22) != 0 && var_r30->layer == j) { - if (((var_r30->attr & 0x800) == 0 && (var_r30->attr & 0x100) == 0) || ((var_r30->attr & 0x100) != 0 && (var_r30->unk_00 & 1) != 0)) { + if ((data->attr & 9) == 0 && (data->camera & temp_r22) != 0 && data->layer == j) { + if (((data->attr & 0x800) == 0 && (data->attr & 0x100) == 0) || ((data->attr & 0x100) != 0 && (data->unk_00 & 1) != 0)) { var_r25 = 0; - var_r30->motion_attr &= 0xBFFFFFFF; - if (var_r30->unk_08 != -1) { - Hu3DMotionExec(i, var_r30->unk_08, var_r30->unk_64, 0); + data->motion_attr &= 0xBFFFFFFF; + if (data->unk_08 != -1) { + Hu3DMotionExec(i, data->unk_08, data->unk_64, 0); } - if (var_r30->unk_0C != -1) { + if (data->unk_0C != -1) { Hu3DSubMotionExec(i); } - if (var_r30->unk_0A != -1) { - Hu3DMotionExec(i, var_r30->unk_0A, var_r30->unk_74, 1); + if (data->unk_0A != -1) { + Hu3DMotionExec(i, data->unk_0A, data->unk_74, 1); } - if ((var_r30->attr & 0x400) != 0) { - ClusterMotionExec(var_r30); + if ((data->attr & 0x400) != 0) { + ClusterMotionExec(data); var_r25 = 1; } - if (var_r30->unk_0E != -1) { - if (var_r30->unk_08 == -1) { - Hu3DMotionExec(i, var_r30->unk_0E, var_r30->unk_94, 0); + if (data->unk_0E != -1) { + if (data->unk_08 == -1) { + Hu3DMotionExec(i, data->unk_0E, data->unk_94, 0); } else { - Hu3DMotionExec(i, var_r30->unk_0E, var_r30->unk_94, 1); + Hu3DMotionExec(i, data->unk_0E, data->unk_94, 1); } var_r25 = 1; } - if ((var_r30->attr & 0x90) == 0 && (var_r30->motion_attr & 0x40000002) == 0) { + if ((data->attr & 0x90) == 0 && (data->motion_attr & 0x40000002) == 0) { var_r25 = 1; - InitVtxParm(var_r30->hsfData); - if (var_r30->unk_0E != -1) { - ShapeProc(var_r30->hsfData); + InitVtxParm(data->hsfData); + if (data->unk_0E != -1) { + ShapeProc(data->hsfData); } - if ((var_r30->attr & 0x400) != 0) { - ClusterProc(var_r30); + if ((data->attr & 0x400) != 0) { + ClusterProc(data); } - if (var_r30->hsfData->cenvCnt != 0) { - EnvelopeProc(var_r30->hsfData); + if (data->hsfData->cenvCnt != 0) { + EnvelopeProc(data->hsfData); } PPCSync(); } if (var_r25 != 0) { GXInvalidateVtxCache(); } - var_r30->attr |= 0x800; + data->attr |= 0x800; } - if (var_r24 != 0 && (var_r30->attr & 0x10) != 0) { + if (var_r24 != 0 && (data->attr & 0x10) != 0) { GXWaitDrawDone(); var_r24 = 0; } - if ((var_r30->attr & 0x8000) == 0 && (lbl_801D4AB4 != var_r30->scale.x || lbl_801D4AB4 != var_r30->scale.y || lbl_801D4AB4 != var_r30->scale.z)) { - mtxRot(sp40, var_r30->rot.x, var_r30->rot.y, var_r30->rot.z); - mtxScaleCat(sp40, var_r30->scale.x, var_r30->scale.y, var_r30->scale.z); - mtxTransCat(sp40, var_r30->pos.x, var_r30->pos.y, var_r30->pos.z); + if ((data->attr & 0x8000) == 0 && (0.0f != data->scale.x || 0.0f != data->scale.y || 0.0f != data->scale.z)) { + mtxRot(sp40, data->rot.x, data->rot.y, data->rot.z); + mtxScaleCat(sp40, data->scale.x, data->scale.y, data->scale.z); + mtxTransCat(sp40, data->pos.x, data->pos.y, data->pos.z); PSMTXConcat(Hu3DCameraMtx, sp40, sp10); - PSMTXConcat(sp10, var_r30->unk_F0, sp10); - Hu3DDraw(var_r30, sp10[0], &var_r30->scale.x); + PSMTXConcat(sp10, data->unk_F0, sp10); + Hu3DDraw(data, sp10[0], &data->scale.x); } - var_r30->unk_00++; + data->unk_00++; var_r23++; if (var_r23 >= layerNum[j]) { break; @@ -257,9 +251,9 @@ void Hu3DExec(void) { } HuSprDispInit(); HuSprExec(0); - var_r30 = Hu3DData; - for (i = 0; i < 0x200; i++, var_r30++) { - if (var_r30->hsfData != 0 && (var_r30->unk_08 != -1 || (var_r30->attr & 0x400) != 0 || var_r30->unk_0E != -1) && (Hu3DPauseF == 0 || (var_r30->attr & 0x200000) != 0)) { + data = Hu3DData; + for (i = 0; i < 0x200; i++, data++) { + if (data->hsfData != 0 && (data->unk_08 != -1 || (data->attr & 0x400) != 0 || data->unk_0E != -1) && (Hu3DPauseF == 0 || (data->attr & 0x200000) != 0)) { Hu3DMotionNext(i); } } @@ -317,6 +311,8 @@ void Hu3DNoSyncSet(s32 arg0) { NoSyncF = arg0; } +// ,,, + s16 Hu3DModelCreate(s32 arg0) { HsfData* temp_r0; ModelData* var_r31; @@ -340,18 +336,18 @@ s16 Hu3DModelCreate(s32 arg0) { var_r31->motion_attr = 0; var_r31->unk_02 = 0; MakeDisplayList(var_r30, (HsfData* ) var_r31->unk_48); - var_r31->unk_68.x = lbl_801D4AB8; + var_r31->unk_68.x = 1.0f; for (i = 0; i < 4; i++) { var_r31->unk_10[i] = -1; } var_r31->unk_0A = -1; var_r31->unk_0C = -1; var_r31->unk_0E = -1; - var_r31->unk_64 = lbl_801D4AB4; + var_r31->unk_64 = 0.0f; if (var_r31->hsfData->motionCnt != 0) { var_r31->unk_08 = var_r31->unk_20 = Hu3DMotionModelCreate(var_r30); if (var_r31->hsfData->cenvCnt != 0) { - Hu3DMotionExec(var_r30, var_r31->unk_08, lbl_801D4AB4, 0); + Hu3DMotionExec(var_r30, var_r31->unk_08, 0.0f, 0); EnvelopeProc(var_r31->hsfData); PPCSync(); } @@ -361,20 +357,20 @@ s16 Hu3DModelCreate(s32 arg0) { if (var_r31->hsfData->shapeCnt != 0) { Hu3DMotionShapeSet(var_r30, var_r31->unk_08); } - var_r31->unk_68.y = lbl_801D4AB4; + var_r31->unk_68.y = 0.0f; var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r30); } else { var_r31->unk_20 = var_r31->unk_08 = -1; } - var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = lbl_801D4AB4; - var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = lbl_801D4AB4; - var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = lbl_801D4AB8; + var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = 0.0f; + var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = 0.0f; + var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 1.0f; var_r31->camera = -1; var_r31->layer = 0; var_r31->unk_120 = 0; var_r31->unk_26 = 0; var_r31->unk_03 = 0; - var_r31->unk_58.x = var_r31->unk_58.z = var_r31->unk_58.y = lbl_801D4AB8; + var_r31->unk_58.x = var_r31->unk_58.z = var_r31->unk_58.y = 1.0f; var_r31->unk_04 = -1; var_r31->unk_24 = -1; @@ -386,7 +382,7 @@ s16 Hu3DModelCreate(s32 arg0) { PSMTXIdentity(var_r31->unk_F0); layerNum[0] += 1; HuMemDCFlush(HEAP_DATA); - if ((var_r31->hsfData->sceneCnt != 0) && ((var_r31->hsfData->scene->start != lbl_801D4AB4) || (var_r31->hsfData->scene->end != lbl_801D4AB4))) { + if ((var_r31->hsfData->sceneCnt != 0) && ((var_r31->hsfData->scene->start != 0.0f) || (var_r31->hsfData->scene->end != 0.0f))) { Hu3DFogSet(var_r31->hsfData->scene->start, var_r31->hsfData->scene->end, var_r31->hsfData->scene->color.r, var_r31->hsfData->scene->color.g, var_r31->hsfData->scene->color.b); } return var_r30; @@ -426,12 +422,12 @@ s16 Hu3DModelLink(s16 arg0) { var_r31->attr = temp_r30->attr; temp_r30->attr |= 0x100000; var_r31->motion_attr = temp_r30->motion_attr; - var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = lbl_801D4AB4; - var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = lbl_801D4AB4; - var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = lbl_801D4AB8; + var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = 0.0f; + var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = 0.0f; + var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 1.0f; var_r31->unk_08 = temp_r30->unk_08; if (var_r31->unk_08 != -1) { - var_r31->unk_68.y = lbl_801D4AB4; + var_r31->unk_68.y = 0.0f; var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r28); } var_r31->unk_0C = var_r31->unk_0A = var_r31->unk_0E = -1; @@ -451,7 +447,7 @@ s16 Hu3DModelLink(s16 arg0) { var_r31->unk_26 = 0; var_r31->unk_03 = 0; var_r31->unk_02 = 0; - var_r31->unk_58.x = var_r31->unk_58.z = var_r31->unk_58.y = lbl_801D4AB8; + var_r31->unk_58.x = var_r31->unk_58.z = var_r31->unk_58.y = 1.0f; var_r31->unk_04 = -1; var_r31->unk_24 = arg0; for (i = 0; i < 8; i++) { @@ -482,16 +478,16 @@ s16 Hu3DHookFuncCreate(HsfData* arg0) { var_r31->unk_48 = (HsfData *)(var_r29 + 0x2710); var_r31->attr = 0x10; var_r31->motion_attr = 0; - var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = lbl_801D4AB4; - var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = lbl_801D4AB4; - var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = lbl_801D4AB8; + var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = 0.0f; + var_r31->rot.x = var_r31->rot.y = var_r31->rot.z = 0.0f; + var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 1.0f; var_r31->unk_08 = var_r31->unk_0C = var_r31->unk_0A = var_r31->unk_0E = -1; for (i = 0; i < 4; i++) { var_r31->unk_10[i] = -1; } - var_r31->unk_64 = lbl_801D4AB4; - var_r31->unk_68.x = lbl_801D4AB8; + var_r31->unk_64 = 0.0f; + var_r31->unk_68.x = 1.0f; var_r31->unk_20 = -1; var_r31->camera = -1; var_r31->layer = 0; @@ -759,12 +755,12 @@ HsfObject* Hu3DModelObjPtrGet(s16 arg0, s32 arg1) { return NULL; } -static inline void inlineFunc(HsfObject* var_r26) { +static inline void inlineFunc(HsfObject* var_r26, u32 a) { HsfConstData* temp_r25; HsfObject* copy = var_r26; - if (copy->type == 2U) { + if (copy->type == HSF_OBJ_MESH) { temp_r25 = copy->constData; - temp_r25->flags |= 1; + temp_r25->flags |= a; } } @@ -781,8 +777,8 @@ void Hu3DModelTPLvlSet(s16 arg0, f32 arg8) { temp_r30 = temp_r28->hsfData; var_r31 = temp_r30->material; for (i = 0; i < temp_r30->materialCnt; i++, var_r31++) { - var_r31->invAlpha = lbl_801D4AB8 - arg8; - if (lbl_801D4AB8 != arg8) { + var_r31->invAlpha = 1.0f - arg8; + if (1.0f != arg8) { var_r31->pass = (var_r31->pass & 0xF0) | 1; } else { var_r31->pass &= 0xF0; @@ -790,11 +786,688 @@ void Hu3DModelTPLvlSet(s16 arg0, f32 arg8) { } var_r26 = temp_r30->object; for (i = 0; i < temp_r30->objectCnt; var_r26++, i++) { - inlineFunc(var_r26); + var_r27 = var_r26; + if (var_r27->type == 2) { + temp_r25 = var_r27->constData; + temp_r25->flags |= 1; + } } temp_r28->attr |= 0x40000; } +void Hu3DModelHiliteMapSet(s16 arg0, AnimData *arg1) { + HsfObject* copy; + ModelData* temp_r30; + HsfData* temp_r29; + s16 i; + HsfObject* var_r27; + HsfConstData* temp_r25; + + temp_r30 = &Hu3DData[arg0]; + temp_r29 = temp_r30->hsfData; + var_r27 = temp_r29->object; + for (i = 0; i < temp_r29->objectCnt; var_r27++, i++) { + copy = var_r27; + if (copy->type == HSF_OBJ_MESH) { + copy->flags |= 0x100; + temp_r25 = copy->constData; + temp_r25->flags |= 0x8000; + temp_r25->hilite_map = arg1; + } + } +} + +static inline void constDataFlagSet(HsfObject* var_r26, u32 a) { + HsfConstData* temp_r25; + HsfObject* copy = var_r26; + if (copy->constData != 0) { + temp_r25 = copy->constData; + temp_r25->flags |= a; + } +} + +static inline void constDataFlagReset(HsfObject* var_r26, u32 a) { + HsfConstData* temp_r25; + HsfObject* copy = var_r26; + if (copy->constData != 0) { + temp_r25 = copy->constData; + temp_r25->flags &= ~a; + } +} + +void Hu3DModelShadowSet(s16 arg0) { + HsfConstData* temp_r26; + HsfData* temp_r30; + HsfConstData* temp_r25; + HsfObject* copy; + s16 var_r28; + HsfObject* var_r27; + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r30 = temp_r31->hsfData; + if ((temp_r31->attr & 4) == 0) { + Hu3DShadowCamBit++; + } + temp_r31->attr |= 4; + var_r27 = temp_r30->object; + + for (var_r28 = 0; var_r28 < temp_r30->objectCnt; var_r28++, var_r27++) { + constDataFlagSet(var_r27, 0x400); + } +} + +void Hu3DModelShadowReset(s16 arg0) { + s16 var_r28; + HsfObject* var_r27; + HsfConstData* temp_r26; + ModelData* temp_r31; + HsfData* temp_r30; + HsfObject* copy; + + temp_r31 = &Hu3DData[(s16) arg0]; + temp_r30 = temp_r31->hsfData; + temp_r31->attr &= ~4; + Hu3DShadowCamBit -= 1; + var_r27 = temp_r30->object; + for (var_r28 = 0; var_r28 < temp_r30->objectCnt; var_r28++, var_r27++) { + constDataFlagReset(var_r27, 0x400); + } +} + +void Hu3DModelShadowDispOn(s16 arg0) { + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r31->attr |= 4; +} + +void Hu3DModelShadowDispOff(s16 arg0) { + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r31->attr &= ~4; +} + +void Hu3DModelShadowMapSet(s16 arg0) { + HsfConstData* temp_r27; + HsfData* temp_r31; + s16 i; + HsfObject* var_r28; + HsfObject* copy; + + temp_r31 = Hu3DData[arg0].hsfData; + var_r28 = temp_r31->object; + for (i = 0; i < temp_r31->objectCnt; i++, var_r28++) { + constDataFlagSet(var_r28, 8); + } +} + +void Hu3DModelShadowMapObjSet(s16 arg0, s32 arg1) { + char name[0x100]; + HsfData* temp_r30; + s16 i; + HsfObject* var_r28; + HsfObject* copy; + HsfConstData* temp_r27; + + temp_r30 = Hu3DData[arg0].hsfData; + var_r28 = temp_r30->object; + strcpy(&name, MakeObjectName(arg1)); + + for (i = 0; i < temp_r30->objectCnt; i++, var_r28++) { + copy = var_r28; + if (copy->constData != 0x0 && strcmp(&name, copy->name) == 0) { + temp_r27 = copy->constData; + temp_r27->flags |= 8; + break; + } + } +} + +void Hu3DModelAmbSet(s16 arg0, f32 arg8, f32 arg9, f32 argA) { + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r31->unk_58.x = arg8; + temp_r31->unk_58.z = arg9; + temp_r31->unk_58.y = argA; +} + +void Hu3DModelHookSet(s16 arg0, s32 arg1, s16 arg2) { + char name[0x100]; + ModelData* data; + HsfData* temp_r30; + s16 i; + HsfConstData *constData; + HsfObject* copy; + HsfObject* var_r27; + + temp_r30 = Hu3DData[arg0].hsfData; + var_r27 = temp_r30->object; + strcpy(&name, MakeObjectName(arg1)); + + for (i = 0; i < temp_r30->objectCnt; i++, var_r27++) { + copy = var_r27; + if (copy->constData != 0) { + if (strcmp(&name, copy->name) == 0) { + constData = copy->constData; + constData->hook = arg2; + data = &Hu3DData[arg2]; + data->attr |= 0x8000; + return; + } else { + (void)data; + } + } + } + OSReport("Error: Not Found %s for HookSet\n", arg1); +} + +void Hu3DModelHookReset(s16 arg0) { + HsfConstData* temp_r31; + HsfData* temp_r30; + HsfObject* copy; + ModelData* temp_r28; + s16 var_r27; + HsfObject* var_r26; + s16 temp_r0; + + temp_r30 = Hu3DData[arg0].hsfData; + var_r26 = temp_r30->object; + for (var_r27 = 0; var_r27 < temp_r30->objectCnt; var_r27++, var_r26++) { + copy = var_r26; + if (copy->constData != 0) { + temp_r31 = copy->constData; + if (temp_r31->hook != -1) { + temp_r0 = temp_r31->hook; + temp_r28 = &Hu3DData[temp_r0]; + temp_r28->attr &= ~0x8000; + temp_r31->hook = -1; + (void)temp_r28; + } + } + } +} + +void Hu3DModelHookObjReset(s16 arg0, s32 arg1) { + char name[0x100]; + ModelData* temp_r28; + HsfData* temp_r30; + HsfObject* copy; + HsfConstData* temp_r29; + s16 i; + HsfObject* var_r26; + s16 temp_r0; + + temp_r30 = Hu3DData[arg0].hsfData; + var_r26 = temp_r30->object; + strcpy(&name, MakeObjectName(arg1)); + + for (i = 0; i < temp_r30->objectCnt; i++, var_r26++) { + copy = var_r26; + if (copy->constData != 0) { + if (strcmp(&name, copy->name) == 0) { + temp_r29 = copy->constData; + temp_r0 = temp_r29->hook; + temp_r28 = &Hu3DData[temp_r0]; + temp_r28->attr &= ~0x8000; + temp_r29->hook = -1; + (void)temp_r28; + return; + } + } + } + + OSReport("Error: Not Found %s for HookReset\n", arg1); +} + +void Hu3DModelProjectionSet(s16 arg0, s16 arg1) { + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r31->unk_02 = temp_r31->unk_02 | (1 << arg1); +} + +void Hu3DModelProjectionReset(s16 arg0, s16 arg1) { + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r31->unk_02 &= ~(1 << arg1); +} + +void Hu3DModelHiliteTypeSet(s16 arg0, s16 arg1) { + HsfData* temp_r30; + HsfMaterial* var_r31; + ModelData* temp_r29; + ModelData* temp_r5; + s16 i; + s32 temp; + + temp_r5 = &Hu3DData[arg0]; + temp_r30 = temp_r5->hsfData; + var_r31 = temp_r30->material; + + arg1 = ((s16) arg1) * 0x10; + arg1 &= 0xF0; + for (i = 0; i < temp_r30->materialCnt; i++, var_r31++) { + var_r31->pass = var_r31->pass & 0xF | arg1; + var_r31->flags |= 0x100; + } + temp_r29 = &Hu3DData[arg0]; + temp_r29->attr |= 0x20000; + (void)temp_r29; +} + +void Hu3DModelReflectTypeSet(s16 arg0, s16 arg1) { + ModelData *copy = &Hu3DData[arg0]; + copy->unk_04 = arg1; +} + +CameraData defCamera = { + 45.0f, + 20.0f, + 5000.0f, + 0.0f, + 1.2f, + {0.0f, 0.0f, 100.0f}, + {0.0f, 1.0f, 0.0f}, + {0.0f, 0.0f, 0.0f}, + 0, 0, 640, 480, + 0.0f, 0.0f, 640.0f, 480.0f, + 0.0f, 1.0f +}; + +void Hu3DCameraCreate(s32 cam) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + defCamera.viewport_w = RenderMode->fbWidth; + defCamera.viewport_h = RenderMode->efbHeight; + defCamera.scissor_w = RenderMode->fbWidth; + defCamera.scissor_h = RenderMode->efbHeight; + Hu3DCameraExistF |= cam; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + *cam_ptr = defCamera; + } + } +} + +void Hu3DCameraPerspectiveSet(s32 cam, f32 fov, f32 near, f32 far, f32 aspect) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + cam_ptr->fov = fov; + cam_ptr->near = near; + cam_ptr->far = far; + cam_ptr->aspect = aspect; + } + } +} + +void Hu3DCameraViewportSet(s32 cam, f32 vx, f32 vy, f32 vw, f32 vh, f32 nz, f32 fz) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + cam_ptr->viewport_x = vx; + cam_ptr->viewport_y = vy; + cam_ptr->viewport_w = vw; + cam_ptr->viewport_h = vh; + cam_ptr->near_z = nz; + cam_ptr->far_z = fz; + } + } +} + +void Hu3DCameraScissorSet(s32 cam, s32 x, s32 y, s32 w, s32 h) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + cam_ptr->scissor_x = x; + cam_ptr->scissor_y = y; + cam_ptr->scissor_w = w; + cam_ptr->scissor_h = h; + } + } +} + +void Hu3DCameraPosSet(s32 cam, f32 x, f32 y, f32 z, f32 ux, f32 uy, f32 uz, f32 tx, f32 ty, f32 tz) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + cam_ptr->pos.x = x; + cam_ptr->pos.y = y; + cam_ptr->pos.z = z; + cam_ptr->up.x = ux; + cam_ptr->up.y = uy; + cam_ptr->up.z = uz; + cam_ptr->target.x = tx; + cam_ptr->target.y = ty; + cam_ptr->target.z = tz; + } + } +} + +void Hu3DCameraPosSetV(s32 cam, Vec pos, Vec up, Vec target) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + cam_ptr->pos = pos; + cam_ptr->up = up; + cam_ptr->target = target; + } + } +} + +void Hu3DCameraKill(s32 cam) { + s16 mask; + s16 i; + CameraData* cam_ptr; + + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1) { + if ((cam & mask) != 0) { + cam_ptr = &Hu3DCamera[i]; + cam_ptr->fov = -1.0f; + } + } +} + +void Hu3DCameraAllKill(void) { + CameraData* cam_ptr; + CameraData* cam_ptr2; + s16 i; + s16 mask; + s16 j; + s16 mask2; + + cam_ptr = &Hu3DCamera[0]; + for (i = 0, mask = 1; i < 0x10; i++, mask <<= 1, cam_ptr++) { + if (-1.0f != cam_ptr->fov) { + for (j = 0, mask2 = 1; j < 0x10; j++, mask2 <<= 1) { + if ((mask & mask2) != 0) { + cam_ptr2 = &Hu3DCamera[j]; + cam_ptr2->fov = -1.0f; + } + } + } + } + Hu3DCameraExistF = 0; +} + +void Hu3DCameraSet(s32 arg0, Mtx arg1) { + Mtx44 sp10; + Mtx44 spC; + CameraData* temp_r31; + + temp_r31 = &Hu3DCamera[arg0]; + C_MTXPerspective(sp10, temp_r31->fov, temp_r31->aspect, temp_r31->near, temp_r31->far); + GXSetProjection(sp10, GX_PERSPECTIVE); + if (RenderMode->field_rendering != 0) { + GXSetViewportJitter(temp_r31->viewport_x, temp_r31->viewport_y, temp_r31->viewport_w, temp_r31->viewport_h, temp_r31->near_z, temp_r31->far_z, VIGetNextField()); + } else { + GXSetViewport(temp_r31->viewport_x, temp_r31->viewport_y, temp_r31->viewport_w, temp_r31->viewport_h, temp_r31->near_z, temp_r31->far_z); + } + GXSetScissor(temp_r31->scissor_x, temp_r31->scissor_y, temp_r31->scissor_w, temp_r31->scissor_h); + C_MTXLookAt(arg1, &temp_r31->pos, &temp_r31->up, &temp_r31->target); +} + +BOOL Hu3DModelCameraInfoSet(s16 arg0, u16 arg1) { + CameraData* cam; + CameraData* temp_r30; + CameraData* temp_r29; + HsfObject* obj_copy; + ModelData* temp_r24; + ModelData* temp_r28; + HsfObject* var_r23; + HsfData* temp_r27; + Point3d sp14; + Point3d sp8; + f32 temp_f31; + s16 i; + s16 var_r25; + s16 var_r26; + s16 var_r21; + s16 var_r20; + + temp_r28 = &Hu3DData[arg0]; + temp_r27 = temp_r28->hsfData; + cam = &Hu3DCamera[arg1]; + var_r23 = temp_r27->object; + + for (i = 0; i < temp_r27->objectCnt; i++, var_r23++) { + obj_copy = var_r23; + if (obj_copy->type == 7) { + temp_f31 = obj_copy->data.base.rot.x; + cam->aspect_dupe = temp_f31; + + PSVECSubtract((Point3d* ) &obj_copy->camera.target, (Point3d* ) &obj_copy->camera.pos, &sp8); + + sp14.x = ((sp8.x * sp8.y * (1.0 - cos((M_PI * temp_f31) / 180.0))) - (sp8.z * sin((M_PI * temp_f31) / 180.0))); + sp14.y = ((sp8.y * sp8.y) + (1.0f - (sp8.y * sp8.y)) * cos((M_PI * temp_f31) / 180.0)); + sp14.z = (((sp8.y * sp8.z) * (1.0 - cos((M_PI * (f64) temp_f31) / 180.0))) + (sp8.x * sin((M_PI * temp_f31) / 180.0))); + PSVECNormalize(&sp14, &sp8); + + Hu3DCameraPosSet(arg1, obj_copy->camera.target.x, obj_copy->camera.target.y, obj_copy->camera.target.z, + sp8.x, sp8.y, sp8.z, + obj_copy->camera.pos.x, obj_copy->camera.pos.y, obj_copy->camera.pos.z); + + Hu3DCameraPerspectiveSet(arg1, obj_copy->camera.fov, obj_copy->camera.near, obj_copy->camera.far, 1.2f); + + temp_r28->unk_01 = arg1; + temp_r24 = &Hu3DData[arg0]; + temp_r24->attr |= 0x2000; + (void)temp_r24; + return 1; + } + } + return 0; +} + +s16 Hu3DModelCameraCreate(s16 arg0, u16 arg1) { + ModelData* temp_r31; + s16 temp_r3; + + temp_r3 = Hu3DHookFuncCreate((HsfData* )-1); + temp_r31 = &Hu3DData[(s16) temp_r3]; + temp_r31->attr &= ~0x10; + temp_r31->attr |= 0x10000 | 0x2000; + temp_r31->unk_08 = arg0; + temp_r31->unk_01 = arg1; + return temp_r3; +} + +void Hu3DCameraMotionOn(s16 arg0, s8 arg1) { + ModelData* copy; + ModelData* copy2; + + copy2 = &Hu3DData[arg0]; + copy2->unk_01 = arg1; + copy = &Hu3DData[arg0]; + copy->attr |= 0x2000; +} + +void Hu3DCameraMotionStart(s16 arg0, u16 arg1) { + ModelData* temp_r30; + ModelData* temp_r29; + ModelData* temp_r28; + ModelData* temp_r27; + + temp_r28 = &Hu3DData[arg0]; + temp_r27 = &Hu3DData[arg0]; + temp_r27->unk_01 = arg1; + temp_r29 = &Hu3DData[arg0]; + temp_r29->attr |= 0x2000; + temp_r30 = &Hu3DData[arg0]; + temp_r30->motion_attr &= ~0x40000002; + Hu3DMotionStartEndSet(arg0, 0.0f, Hu3DMotionMotionMaxTimeGet(temp_r28->unk_08)); + Hu3DMotionTimeSet(arg0, 0.0f); +} + +void Hu3DCameraMotionOff(s16 arg0) { + ModelData* temp_r31; + + temp_r31 = &Hu3DData[arg0]; + temp_r31->attr &= ~0x2000; +} + +void Hu3DLighInit(void) { + LightData* var_r31; + s16 var_r30; + + var_r31 = Hu3DGlobalLight; + for (var_r30 = 0; var_r30 < 8; var_r30++, var_r31++) { + var_r31->unk_00 = -1; + } + var_r31 = Hu3DLocalLight; + for (var_r30 = 0; var_r30 < 0x20; var_r30++, var_r31++) { + var_r31->unk_00 = -1; + } +} + +void Hu3DGLightCreate(f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD, u8 arg0, u8 arg1, u8 arg2) { + Vec vec1; + Vec vec2; + GXColor color; + + vec1.x = arg8; + vec1.y = arg9; + vec1.z = argA; + vec2.x = argB; + vec2.y = argC; + vec2.z = argD; + color.r = arg0; + color.g = arg1; + color.b = arg2; + color.a = 0xFF; + Hu3DGLightCreateV(&vec1, &vec2, &color); +} + +s16 Hu3DGLightCreateV(Vec* arg0, Vec* arg1, GXColor* arg2) { + s16 var_r30; + LightData* var_r31; + + var_r31 = Hu3DGlobalLight; + + for (var_r30 = 0; var_r30 < 8; var_r30++, var_r31++) { + if (var_r31->unk_00 == -1) { + break; + } + } + if (var_r30 == 8) { + return -1; + } + var_r31->unk_00 = 0; + var_r31->unk_1C = *arg0; + var_r31->unk_28 = *arg1; + var_r31->unk_34.x = var_r31->unk_34.y = var_r31->unk_34.z = 0.0f; + var_r31->unk_04 = 0.0f; + var_r31->unk_02 = 2; + + PSVECNormalize(&var_r31->unk_28, &var_r31->unk_28); + var_r31->color = *arg2; + return var_r30; +} + +void Hu3DLLightCreate(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD, u8 arg1, u8 arg2, u8 arg3) { + Vec vec1; + Vec vec2; + GXColor color; + + vec1.x = arg8; + vec1.y = arg9; + vec1.z = argA; + vec2.x = argB; + vec2.y = argC; + vec2.z = argD; + color.r = arg1; + color.g = arg2; + color.b = arg3; + color.a = 0xFF; + Hu3DLLightCreateV(arg0, &vec1, &vec2, &color); +} + +s16 Hu3DLLightCreateV(s16 arg0, Vec* arg1, Vec* arg2, GXColor* arg3) { + ModelData* temp_r29; + s16 var_r28; + s16 var_r30; + LightData* var_r31; + + temp_r29 = &Hu3DData[arg0]; + var_r31 = Hu3DLocalLight; + for (var_r28 = 0; var_r28 < 0x20; var_r28++, var_r31++) { + if (var_r31->unk_00 == -1) { + break; + } + } + if (var_r28 == 0x20) { + return -1; + } + var_r31->unk_00 = 0; + var_r31->unk_1C = *arg1; + var_r31->unk_28 = *arg2; + var_r31->unk_34.x = var_r31->unk_34.y = var_r31->unk_34.z = 0.0f; + var_r31->unk_04 = 30.0f; + var_r31->unk_02 = 2; + PSVECNormalize(&var_r31->unk_28, &var_r31->unk_28); + var_r31->color = *arg3; + + for (var_r30 = 0; var_r30 < 8; var_r30++) { + if (temp_r29->unk_38[var_r30] == -1) { + break; + } + } + if (var_r30 == 8) { + return -1; + } + temp_r29->unk_38[var_r30] = var_r28; + temp_r29->attr |= 0x1000; + return var_r30; +} + +void Hu3DGLightSpotSet(s16 arg0, u16 arg1, f32 arg8) { + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[arg0]; + temp_r31->unk_00 &= 0xFF00; + temp_r31->unk_04 = arg8; + temp_r31->unk_02 = arg1; +} + +void Hu3DLLightSpotSet(s16 arg0, s16 arg1, u16 arg2, f32 arg8) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[arg0]; + temp_r31 = &Hu3DLocalLight[data->unk_38[arg1]]; + temp_r31->unk_00 &= 0xFF00; + temp_r31->unk_04 = arg8; + temp_r31->unk_02 = arg2; +} + // ... void Hu3DShadowSizeSet(u16 arg0) { @@ -805,6 +1478,38 @@ void Hu3DShadowSizeSet(u16 arg0) { Hu3DShadowData.unk_04 = HuMemDirectMalloc(HEAP_DATA, arg0 * arg0); } +s16 Hu3DProjectionCreate(void *arg0, f32 arg8, f32 arg9, f32 argA) { + s16 var_r30; + ThreeDProjectionStruct* var_r31; + + var_r31 = Hu3DProjection; + + for (var_r30 = 0; var_r30 < 4; var_r30++, var_r31++) { + if (var_r31->unk_04 == 0U) { + break; + } + } + if ((s16) var_r30 == 4) { + return -1; + } + var_r31->unk_04 = arg0; + var_r31->unk_08.x = arg8; + var_r31->unk_08.y = arg9; + var_r31->unk_08.z = argA; + var_r31->unk_14.x = 1000.0f; + var_r31->unk_14.y = 1000.0f; + var_r31->unk_14.z = 0.0f; + var_r31->unk_20.x = var_r31->unk_20.y = var_r31->unk_20.z = 0.0f; + var_r31->unk_2C.x = -1.0f; + var_r31->unk_2C.y = 1.0f; + var_r31->unk_2C.z = 0.0f; + C_MTXLightPerspective(var_r31->unk_68, arg8, 1.2f, 0.5f, 20.0f, 0.5f, 0.5f); + PSVECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); + var_r31->unk_00 = 0x80; + Hu3DProjectionNum++; + return var_r30; +} + void Hu3DProjectionKill(s16 arg0) { HuSprAnimKill(Hu3DProjection[arg0].unk_04); Hu3DProjection[arg0].unk_04 = NULL; @@ -817,7 +1522,7 @@ void Hu3DProjectionPosSet(s16 arg0, Vec arg1, Vec arg2, Vec arg3) { } void Hu3DProjectionTPLvlSet(s16 arg0, f32 arg8) { - Hu3DProjection[arg0].unk_00 = (s8) (lbl_801D4AFC * arg8); + Hu3DProjection[arg0].unk_00 = 255.0f * arg8; } void Hu3DMipMapSet(char* arg0, s16 arg1, s32 arg2, f32 arg8) { From 6abaa5e72e52789d0d47c2c62fc62875b60e7b99 Mon Sep 17 00:00:00 2001 From: CreateSource <72283721+abnormalhare@users.noreply.github.com> Date: Wed, 13 Dec 2023 08:41:43 -0500 Subject: [PATCH 2/3] Fix my stupidity Hehe. --- config/GMPE01_00/symbols.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index d51eb189..efbf068c 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -5425,7 +5425,7 @@ FogData = .bss:0x8018C88C; // type:object size:0x10 data:4byte Hu3DCameraMtx = .bss:0x8018C89C; // type:object size:0x30 Hu3DCameraMtxXPose = .bss:0x8018C8CC; // type:object size:0x30 Hu3DGlobalLight = .bss:0x8018C8FC; // type:object size:0x220 data:2byte -Hu3DLocalLight = .bss:0x8018CB1C; // type:object size:0x8B4 data:2byte +Hu3DLocalLight = .bss:0x8018CB1C; // type:object size:0x880 data:2byte lbl_8018D39C = .bss:0x8018D39C; // type:object size:0x48 Hu3DMotion = .bss:0x8018D3D0; // type:object size:0x800 data:2byte Hu3DTexAnimData = .bss:0x8018DBD0; // type:object size:0x1400 data:2byte From f2ed7a84f090c4f9ed76ba9dc47e9fb0f19715d3 Mon Sep 17 00:00:00 2001 From: CreateSource Date: Sun, 17 Dec 2023 14:02:08 -0500 Subject: [PATCH 3/3] closing in --- configure.py | 2 +- include/game/hsfman.h | 34 ++++- src/game/hsfman.c | 310 ++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 332 insertions(+), 14 deletions(-) diff --git a/configure.py b/configure.py index e7ba6984..7a8c1ec1 100644 --- a/configure.py +++ b/configure.py @@ -247,7 +247,7 @@ config.libs = [ Object(Matching, "game/sprput.c"), Object(Matching, "game/hsfload.c"), Object(NonMatching, "game/hsfdraw.c"), - Object(NonMatching, "game/hsfman.c"), + Object(Matching, "game/hsfman.c"), Object(NonMatching, "game/hsfmotion.c"), Object(NonMatching, "game/hsfanim.c"), Object(NonMatching, "game/hsfex.c"), diff --git a/include/game/hsfman.h b/include/game/hsfman.h index e4eaab3a..64fb0b25 100644 --- a/include/game/hsfman.h +++ b/include/game/hsfman.h @@ -94,7 +94,8 @@ typedef struct light_data { s16 unk_00; s16 unk_02; f32 unk_04; - char unk_08[0x14]; + f32 unk_08; + char unk_0C[0x10]; Vec unk_1C; Vec unk_28; Vec unk_34; @@ -207,10 +208,37 @@ void Hu3DCameraMotionOn(s16, s8); void Hu3DCameraMotionStart(s16, u16); void Hu3DCameraMotionOff(s16); void Hu3DLighInit(void); -void Hu3DGLightCreate(f32, f32, f32, f32, f32, f32, u8, u8, u8); +s16 Hu3DGLightCreate(f32, f32, f32, f32, f32, f32, u8, u8, u8); s16 Hu3DGLightCreateV(Vec*, Vec*, GXColor*); -void Hu3DLLightCreate(s16, f32, f32, f32, f32, f32, f32, u8, u8, u8); +s16 Hu3DLLightCreate(s16, f32, f32, f32, f32, f32, f32, u8, u8, u8); s16 Hu3DLLightCreateV(s16, Vec*, Vec*, GXColor*); +void Hu3DGLightSpotSet(s16, u16, f32); +void Hu3DLLightSpotSet(s16, s16, u16, f32); +void Hu3DGLightInfinitytSet(s16); +void Hu3DLLightInfinitytSet(s16, s16); +void Hu3DGLightPointSet(s16, u16, f32, f32); +void Hu3DLLightPointSet(s16, s16, u16, f32, f32); +void Hu3DGLightKill(s16); +void Hu3DLLightKill(s16, s16); +void Hu3DLightAllKill(void); +void Hu3DGLightColorSet(s16, u8, u8, u8, u8); +void Hu3DLLightColorSet(s16, s16, u8, u8, u8, u8); +void Hu3DGLightPosSetV(s16, Vec*, Point3d*); +void Hu3DLLightPosSetV(s16, s16, Vec*, Point3d*); +void Hu3DGLightPosSet(s16, f32, f32, f32, f32, f32, f32); +void Hu3DLLightPosSet(s16, s16, f32, f32, f32, f32, f32, f32); +void Hu3DGLightPosAimSetV(s16, Point3d*, Point3d*); +void Hu3DLLightPosAimSetV(s16, s16, Point3d*, Point3d*); +void Hu3DGLightPosAimSet(s16, f32, f32, f32, f32, f32, f32); +void Hu3DLLightPosAimSet(s16, s16, f32, f32, f32, f32, f32, f32); +void Hu3DGLightStaticSet(s16, s32); +void Hu3DLLightStaticSet(s16, s16, s32); +//... +s16 Hu3DLightSet(ModelData*, s32, s32, f32); +void lightSet(LightData*, s16, s32, s32, f32); +//... +void Hu3DFogSet(f32, f32, u8, u8, u8); +void Hu3DFogClear(void); //... void Hu3DShadowSizeSet(u16); void Hu3DProjectionKill(s16); diff --git a/src/game/hsfman.c b/src/game/hsfman.c index b60e1205..c0d26f6d 100644 --- a/src/game/hsfman.c +++ b/src/game/hsfman.c @@ -108,7 +108,7 @@ void Hu3DPreProc(void) { } void Hu3DExec(void) { - GXColor unusedColor; + GXColor unusedColor = {0, 0, 0, 0}; CameraData* camera; ModelData* data; s16 temp_r22; @@ -122,7 +122,6 @@ void Hu3DExec(void) { Mtx sp10; ThreeDProjectionStruct* var_r26; - unusedColor = lbl_801D6BE0; HuPerfBegin(3); GXSetCurrentMtx(0U); camera = Hu3DCamera; @@ -311,8 +310,6 @@ void Hu3DNoSyncSet(s32 arg0) { NoSyncF = arg0; } -// ,,, - s16 Hu3DModelCreate(s32 arg0) { HsfData* temp_r0; ModelData* var_r31; @@ -955,9 +952,8 @@ void Hu3DModelHookSet(s16 arg0, s32 arg1, s16 arg2) { constData->hook = arg2; data = &Hu3DData[arg2]; data->attr |= 0x8000; - return; - } else { (void)data; + return; } } } @@ -1348,7 +1344,7 @@ void Hu3DLighInit(void) { } } -void Hu3DGLightCreate(f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD, u8 arg0, u8 arg1, u8 arg2) { +s16 Hu3DGLightCreate(f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD, u8 arg0, u8 arg1, u8 arg2) { Vec vec1; Vec vec2; GXColor color; @@ -1363,7 +1359,7 @@ void Hu3DGLightCreate(f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD color.g = arg1; color.b = arg2; color.a = 0xFF; - Hu3DGLightCreateV(&vec1, &vec2, &color); + return Hu3DGLightCreateV(&vec1, &vec2, &color); } s16 Hu3DGLightCreateV(Vec* arg0, Vec* arg1, GXColor* arg2) { @@ -1392,7 +1388,7 @@ s16 Hu3DGLightCreateV(Vec* arg0, Vec* arg1, GXColor* arg2) { return var_r30; } -void Hu3DLLightCreate(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD, u8 arg1, u8 arg2, u8 arg3) { +s16 Hu3DLLightCreate(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD, u8 arg1, u8 arg2, u8 arg3) { Vec vec1; Vec vec2; GXColor color; @@ -1407,7 +1403,7 @@ void Hu3DLLightCreate(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC color.g = arg2; color.b = arg3; color.a = 0xFF; - Hu3DLLightCreateV(arg0, &vec1, &vec2, &color); + return Hu3DLLightCreateV(arg0, &vec1, &vec2, &color); } s16 Hu3DLLightCreateV(s16 arg0, Vec* arg1, Vec* arg2, GXColor* arg3) { @@ -1468,6 +1464,300 @@ void Hu3DLLightSpotSet(s16 arg0, s16 arg1, u16 arg2, f32 arg8) { temp_r31->unk_02 = arg2; } +void Hu3DGLightInfinitytSet(s16 lightIndex) { + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[lightIndex]; + temp_r31->unk_00 &= 0xFF00; + temp_r31->unk_00 |= 1; +} + +void Hu3DLLightInfinitytSet(s16 dataIndex, s16 lightIndex) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[dataIndex]; + temp_r31 = &Hu3DLocalLight[data->unk_38[lightIndex]]; + temp_r31->unk_00 &= 0xFF00; + temp_r31->unk_00 |= 1; +} + +void Hu3DGLightPointSet(s16 arg0, u16 arg1, f32 arg8, f32 arg9) { + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[arg0]; + temp_r31->unk_00 &= 0xFF00; + temp_r31->unk_00 |= 2; + temp_r31->unk_04 = arg8; + temp_r31->unk_08 = arg9; + temp_r31->unk_02 = arg1; +} + +void Hu3DLLightPointSet(s16 arg0, s16 arg1, u16 arg2, f32 arg8, f32 arg9) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[arg0]; + temp_r31 = &Hu3DLocalLight[data->unk_38[arg1]]; + temp_r31->unk_00 &= 0xFF00; + temp_r31->unk_00 |= 2; + temp_r31->unk_04 = arg8; + temp_r31->unk_08 = arg9; + temp_r31->unk_02 = arg2; +} + +void Hu3DGLightKill(s16 index) { + Hu3DGlobalLight[index].unk_00 = -1; +} + +void Hu3DLLightKill(s16 dataIndex, s16 lightIndex) { + ModelData* temp_r31; + LightData* light; + s16 var_r30; + + temp_r31 = &Hu3DData[dataIndex]; + light = &Hu3DLocalLight[temp_r31->unk_38[lightIndex]]; + light->unk_00 = -1; + temp_r31->unk_38[lightIndex] = -1; + + for (var_r30 = 0; var_r30 < 8; var_r30++) { + if (temp_r31->unk_38[var_r30] == -1) { + break; + } + } + if (var_r30 == 8) { + temp_r31->attr &= ~0x1000; + } +} + +void Hu3DLightAllKill(void) { + s16 i; + LightData* light; + + light = Hu3DGlobalLight; + for (i = 0; i < 8; i++, light++) { + if (light->unk_00 != -1) { + Hu3DGlobalLight[i].unk_00 = -1; + } + } +} + +void Hu3DGLightColorSet(s16 arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4) { + LightData* light; + + light = &Hu3DGlobalLight[arg0]; + light->color.r = arg1; + light->color.g = arg2; + light->color.b = arg3; + light->color.a = arg4; +} + +void Hu3DLLightColorSet(s16 arg0, s16 arg1, u8 arg2, u8 arg3, u8 arg4, u8 arg5) { + LightData* light; + ModelData* data; + + data = &Hu3DData[arg0]; + light = &Hu3DLocalLight[data->unk_38[arg1]]; + light->color.r = arg2; + light->color.g = arg3; + light->color.b = arg4; + light->color.a = arg5; +} + +void Hu3DGLightPosSetV(s16 arg0, Vec* arg1, Point3d* arg2) { + Point3d* spC; + s16 sp8; + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[arg0]; + temp_r31->unk_1C = *arg1; + + PSVECNormalize(arg2, &temp_r31->unk_28); +} + +void Hu3DLLightPosSetV(s16 arg0, s16 arg1, Vec* arg2, Point3d* arg3) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[arg0]; + temp_r31 = &Hu3DLocalLight[data->unk_38[arg1]]; + temp_r31->unk_1C = *arg2; + + PSVECNormalize(arg3, &temp_r31->unk_28); +} + +void Hu3DGLightPosSet(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD) { + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[arg0]; + temp_r31->unk_1C.x = arg8; + temp_r31->unk_1C.y = arg9; + temp_r31->unk_1C.z = argA; + temp_r31->unk_28.x = argB; + temp_r31->unk_28.y = argC; + temp_r31->unk_28.z = argD; + PSVECNormalize(&temp_r31->unk_28, &temp_r31->unk_28); +} + +void Hu3DLLightPosSet(s16 arg0, s16 arg1, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[arg0]; + temp_r31 = &Hu3DLocalLight[data->unk_38[arg1]]; + temp_r31->unk_1C.x = arg8; + temp_r31->unk_1C.y = arg9; + temp_r31->unk_1C.z = argA; + temp_r31->unk_28.x = argB; + temp_r31->unk_28.y = argC; + temp_r31->unk_28.z = argD; + PSVECNormalize(&temp_r31->unk_28, &temp_r31->unk_28); +} + +void Hu3DGLightPosAimSetV(s16 arg0, Point3d* arg1, Point3d* arg2) { + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[arg0]; + temp_r31->unk_1C = *arg1; + + PSVECSubtract(arg2, arg1, &temp_r31->unk_28); + PSVECNormalize(&temp_r31->unk_28, &temp_r31->unk_28); +} + +void Hu3DLLightPosAimSetV(s16 arg0, s16 arg1, Point3d* arg2, Point3d* arg3) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[arg0]; + temp_r31 = &Hu3DLocalLight[data->unk_38[arg1]]; + temp_r31->unk_1C = *arg2; + + PSVECSubtract(arg3, arg2, &temp_r31->unk_28); + PSVECNormalize(&temp_r31->unk_28, &temp_r31->unk_28); +} + +void Hu3DGLightPosAimSet(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD) { + Vec vec2; + Vec vec1; + LightData* temp_r30; + LightData* temp_r31; + + vec2.x = arg8; + vec2.y = arg9; + vec2.z = argA; + vec1.x = argB; + vec1.y = argC; + vec1.z = argD; + + temp_r30 = &Hu3DGlobalLight[arg0]; + temp_r31 = temp_r30; + temp_r31->unk_1C = vec2; + PSVECSubtract(&vec1, &vec2, &temp_r31->unk_28); + PSVECNormalize(&temp_r31->unk_28, &temp_r31->unk_28); +} + +void Hu3DLLightPosAimSet(s16 arg0, s16 arg1, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD) { + Vec vec2; + Vec vec1; + ModelData* data; + LightData* temp_r30; + LightData* temp_r31; + + vec2.x = arg8; + vec2.y = arg9; + vec2.z = argA; + vec1.x = argB; + vec1.y = argC; + vec1.z = argD; + + data = &Hu3DData[arg0]; + temp_r30 = &Hu3DLocalLight[data->unk_38[arg1]]; + temp_r31 = temp_r30; + temp_r31->unk_1C = vec2; + PSVECSubtract(&vec1, &vec2, &temp_r31->unk_28); + PSVECNormalize(&temp_r31->unk_28, &temp_r31->unk_28); +} + +void Hu3DGLightStaticSet(s16 arg0, s32 arg1) { + LightData* temp_r31; + + temp_r31 = &Hu3DGlobalLight[arg0]; + if (arg1 != 0) temp_r31->unk_00 |= 0x8000; + else temp_r31->unk_00 &= ~0x8000; +} + +void Hu3DLLightStaticSet(s16 arg0, s16 arg1, s32 arg2) { + ModelData* data; + LightData* temp_r31; + + data = &Hu3DData[arg0]; + temp_r31 = &Hu3DLocalLight[data->unk_38[arg1]]; + if (arg2 != 0) temp_r31->unk_00 |= 0x8000; + else temp_r31->unk_00 &= ~0x8000; +} + +// ... + +s16 Hu3DLightSet(ModelData* arg0, s32 arg1, s32 arg2, f32 arg8) { + s16 var_r30; + LightData* var_r29; + s16 var_r28; + s16 i; + + var_r28 = 0; + var_r30 = 1; + var_r29 = Hu3DGlobalLight; + + for (i = 0; i < 8; i++, var_r29++) { + if (var_r29->unk_00 != -1) { + lightSet(var_r29, var_r30, arg2, arg1, arg8); + var_r28 |= var_r30; + var_r30 = (s16) var_r30 * 2; + } + } + if ((arg0->attr & 0x1000) != 0) { + for (i = 0; i < 8; i++) { + if (arg0->unk_38[i] != -1) { + var_r29 = &Hu3DLocalLight[arg0->unk_38[i]]; + lightSet(var_r29, var_r30, arg2, arg1, arg8); + var_r28 |= var_r30; + var_r30 = (s16) var_r30 * 2; + } + } + } + return var_r28; +} + +// ... + +void Hu3DReflectMapSet(AnimData* arg0) { + + if (reflectAnim[0] != (AnimData*) refMapData0) { + HuMemDirectFree(reflectAnim[0]); + } + reflectAnim[0] = HuSprAnimRead(arg0); + reflectMapNo = 0; +} + +void Hu3DReflectNoSet(s16 arg0) { + reflectMapNo = arg0; +} + +void Hu3DFogSet(f32 arg0, f32 arg1, u8 arg2, u8 arg3, u8 arg4) { + FogData.fogType = 4; + FogData.start = arg0; + FogData.end = arg1; + FogData.color.r = arg2; + FogData.color.g = arg3; + FogData.color.b = arg4; + FogData.color.a = 0xFF; +} + +void Hu3DFogClear(void) { + FogData.fogType = 0; + GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, BGColor); +} + // ... void Hu3DShadowSizeSet(u16 arg0) {