diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt index ed79ad30..6b18f038 100644 --- a/config/SOUE01/splits.txt +++ b/config/SOUE01/splits.txt @@ -101,6 +101,7 @@ toBeSorted/d_unk_mdl_stuff_2.cpp: toBeSorted/blur_and_palette_manager.cpp: .text start:0x800221A0 end:0x800268AC align:16 .ctors start:0x804DB65C end:0x804DB660 + .data start:0x80500E80 end:0x80500E98 .sbss start:0x80575068 end:0x80575070 .sdata2 start:0x80576BA0 end:0x80576C18 .bss start:0x8058F210 end:0x80594FA0 diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt index b22d8282..1e0f9677 100644 --- a/config/SOUE01/symbols.txt +++ b/config/SOUE01/symbols.txt @@ -583,7 +583,7 @@ insertNode__3d3dFPQ23d3d12SomeListNodeff = .text:0x80017380; // type:function si clearList__3d3dFv = .text:0x80017430; // type:function size:0xCC fn_80017500 = .text:0x80017500; // type:function size:0x1DC fn_800176E0 = .text:0x800176E0; // type:function size:0x10 -unk2__3d3dFRQ34nw4r3g3d6ResMatRQ34nw4r3g3d14ResMatTevColorP12LightingInfo = .text:0x800176F0; // type:function size:0x418 +unk2__3d3dFRQ34nw4r3g3d6ResMatRQ34nw4r3g3d14ResMatTevColorP13ActorLighting = .text:0x800176F0; // type:function size:0x418 setRoomTevColors__3d3dFQ34nw4r3g3d6ResMdlib = .text:0x80017B10; // type:function size:0x1D4 fn_80017CF0 = .text:0x80017CF0; // type:function size:0x230 fn_80017F20 = .text:0x80017F20; // type:function size:0x20C @@ -812,53 +812,53 @@ shadow_cut__21BlurAndPaletteManagerFP16SHADOW_INFLUENCE = .text:0x800229D0; // t shadow_influence__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022A10; // type:function size:0xD8 setLightFilter__21BlurAndPaletteManagerFf = .text:0x80022AF0; // type:function size:0x3C set0x35B0__21BlurAndPaletteManagerFf = .text:0x80022B30; // type:function size:0x8 -fn_80022B40 = .text:0x80022B40; // type:function size:0x58 -fn_80022BA0 = .text:0x80022BA0; // type:function size:0xC -fn_80022BB0 = .text:0x80022BB0; // type:function size:0xC -fn_80022BC0 = .text:0x80022BC0; // type:function size:0xC -fn_80022BD0 = .text:0x80022BD0; // type:function size:0xC -fn_80022BE0 = .text:0x80022BE0; // type:function size:0xC -fn_80022BF0 = .text:0x80022BF0; // type:function size:0xBC -fn_80022CB0 = .text:0x80022CB0; // type:function size:0xD8 -fn_80022D90 = .text:0x80022D90; // type:function size:0xD8 -fn_80022E70 = .text:0x80022E70; // type:function size:0x40 -fn_80022EB0 = .text:0x80022EB0; // type:function size:0x5C -fn_80022F10 = .text:0x80022F10; // type:function size:0x8C -fn_80022FA0 = .text:0x80022FA0; // type:function size:0x34 -fn_80022FE0 = .text:0x80022FE0; // type:function size:0x8 -fn_80022FF0 = .text:0x80022FF0; // type:function size:0x8 -combineColors__21BlurAndPaletteManagerFRC6mColorRC6mColorf = .text:0x80023000; // type:function size:0x144 +setBPM8__21BlurAndPaletteManagerFPC7mVec3_cUlf = .text:0x80022B40; // type:function size:0x58 +setBPM8_Type4__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022BA0; // type:function size:0xC +setBPM8_Type6__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022BB0; // type:function size:0xC +setBPM8_Type10__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022BC0; // type:function size:0xC +setBPM8_Type10_2__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022BD0; // type:function size:0xC +setBPM8_Type6_2__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022BE0; // type:function size:0xC +check_BPM8__21BlurAndPaletteManagerFPC7mVec3_cP7mVec3_c = .text:0x80022BF0; // type:function size:0xBC +check_BPM8_1001__21BlurAndPaletteManagerFPC7mVec3_cP7mVec3_c = .text:0x80022CB0; // type:function size:0xD8 +check_BPM8_501__21BlurAndPaletteManagerFPC7mVec3_cP7mVec3_c = .text:0x80022D90; // type:function size:0xD8 +setUnk__21BlurAndPaletteManagerFPC7mVec3_cf = .text:0x80022E70; // type:function size:0x40 +setBPM9__21BlurAndPaletteManagerFPC7mVec3_cf = .text:0x80022EB0; // type:function size:0x5C +check_BPM9__21BlurAndPaletteManagerFPC7mVec3_c = .text:0x80022F10; // type:function size:0x8C +checkBPM9_Entity__21BlurAndPaletteManagerFP7mVec3_c = .text:0x80022FA0; // type:function size:0x34 +setAlterateRoomId__21BlurAndPaletteManagerFl = .text:0x80022FE0; // type:function size:0x8 +getAlterateRoomId__21BlurAndPaletteManagerFv = .text:0x80022FF0; // type:function size:0x8 +color_ratio_set__21BlurAndPaletteManagerFRC6mColorRC6mColorf = .text:0x80023000; // type:function size:0x144 __ct__6mColorFv = .text:0x80023150; // type:function size:0xC -fn_80023160 = .text:0x80023160; // type:function size:0x4C -fn_800231B0 = .text:0x800231B0; // type:function size:0x10 -fn_800231C0 = .text:0x800231C0; // type:function size:0x5C -fn_80023220 = .text:0x80023220; // type:function size:0x60 -fn_80023280 = .text:0x80023280; // type:function size:0xD24 +vec_ratio_set__21BlurAndPaletteManagerFRC7mVec3_cRC7mVec3_cf = .text:0x80023160; // type:function size:0x4C +f32_ratio_set__21BlurAndPaletteManagerFfff = .text:0x800231B0; // type:function size:0x10 +u16_ratio_set__21BlurAndPaletteManagerFUsUsf = .text:0x800231C0; // type:function size:0x5C +u8_ratio_set__21BlurAndPaletteManagerFUcUcf = .text:0x80023220; // type:function size:0x60 +spf_ratio_set__21BlurAndPaletteManagerFR3SpfRC3SpfRC3Spff = .text:0x80023280; // type:function size:0xD24 __as__6mColorFRC6mColor = .text:0x80023FB0; // type:function size:0x24 __as__14UnalignedColorFRC6mColor = .text:0x80023FE0; // type:function size:0x24 __ct__3SpfFv = .text:0x80024010; // type:function size:0x114 __ct__6SffSubFv = .text:0x80024130; // type:function size:0xC __dt__6SffSubFv = .text:0x80024140; // type:function size:0x40 __dt__3SpfFv = .text:0x80024180; // type:function size:0xBC -fn_80024240__21BlurAndPaletteManagerFsss = .text:0x80024240; // type:function size:0xF8 -fn_80024340 = .text:0x80024340; // type:function size:0x10 -BlurAndPaletteMgr__setMist = .text:0x80024350; // type:function size:0x18 -fn_80024370 = .text:0x80024370; // type:function size:0x58 -BlurAndPaletteMgr__setDof = .text:0x800243D0; // type:function size:0x10 -BlurAndPaletteMgr__disableDofOverride = .text:0x800243E0; // type:function size:0xC -fn_800243F0 = .text:0x800243F0; // type:function size:0x178 +set_palette_transition__21BlurAndPaletteManagerFssl = .text:0x80024240; // type:function size:0xF8 +set_override_spf__21BlurAndPaletteManagerFssf = .text:0x80024340; // type:function size:0x10 +setMist__21BlurAndPaletteManagerFUcUcUcff = .text:0x80024350; // type:function size:0x18 +setMistMode3__21BlurAndPaletteManagerFRC7mVec3_cf = .text:0x80024370; // type:function size:0x58 +setDOF__21BlurAndPaletteManagerFf = .text:0x800243D0; // type:function size:0x10 +disableDOF__21BlurAndPaletteManagerFv = .text:0x800243E0; // type:function size:0xC +light_influence_ratio_set__21BlurAndPaletteManagerFR15LIGHT_INFLUENCERC15LIGHT_INFLUENCERC15LIGHT_INFLUENCEf = .text:0x800243F0; // type:function size:0x178 __ct__6mColorFiiii = .text:0x80024570; // type:function size:0x14 -fn_80024590 = .text:0x80024590; // type:function size:0xE4 +sff_ratio_set__21BlurAndPaletteManagerFR3SffRC3SffRC3Sfff = .text:0x80024590; // type:function size:0xE4 __ct__3SffFv = .text:0x80024680; // type:function size:0x48 __dt__3SffFv = .text:0x800246D0; // type:function size:0x64 -fn_80024740 = .text:0x80024740; // type:function size:0x24 -fn_80024770__21BlurAndPaletteManagerFi = .text:0x80024770; // type:function size:0x24 -fn_800247A0__21BlurAndPaletteManagerFi = .text:0x800247A0; // type:function size:0x30 -fn_800247D0__21BlurAndPaletteManagerF7mVec3_cf = .text:0x800247D0; // type:function size:0x20 +fn_80024740__21BlurAndPaletteManagerFUcUc = .text:0x80024740; // type:function size:0x24 +fn_80024770__21BlurAndPaletteManagerFUc = .text:0x80024770; // type:function size:0x24 +fn_800247A0__21BlurAndPaletteManagerFUc = .text:0x800247A0; // type:function size:0x30 +setWind__21BlurAndPaletteManagerF7mVec3_cf = .text:0x800247D0; // type:function size:0x20 __ct__21BlurAndPaletteManagerFv = .text:0x800247F0; // type:function size:0xBB0 __ct__7mVec3_cFfff = .text:0x800253A0; // type:function size:0x10 __ct__12EFLIGHT_PROCFv = .text:0x800253B0; // type:function size:0xC -__ct__4Bpm2Fv = .text:0x800253C0; // type:function size:0x4 +__ct__14WIND_INFLUENCEFv = .text:0x800253C0; // type:function size:0x4 __ct__16SHADOW_INFLUENCEFv = .text:0x800253D0; // type:function size:0x4 __dt__16SHADOW_INFLUENCEFv = .text:0x800253E0; // type:function size:0x40 __ct__4Bpm8Fv = .text:0x80025420; // type:function size:0x4 @@ -881,13 +881,13 @@ __as__3SpfFRC3Spf = .text:0x80025820; // type:function size:0x8C4 __as__3SffFRC3Sff = .text:0x800260F0; // type:function size:0xB4 __as__17PaletteDefaultMCFFRC17PaletteDefaultMCF = .text:0x800261B0; // type:function size:0x154 __dt__21BlurAndPaletteManagerFv = .text:0x80026310; // type:function size:0x1EC -fn_80026500 = .text:0x80026500; // type:function size:0x38 -fn_80026540 = .text:0x80026540; // type:function size:0x40 -fn_80026580 = .text:0x80026580; // type:function size:0x188 -fn_80026710 = .text:0x80026710; // type:function size:0x4C -fn_80026760 = .text:0x80026760; // type:function size:0x4C -getLightColor1__21BlurAndPaletteManagerFv = .text:0x800267B0; // type:function size:0x4C -getLightColor2__21BlurAndPaletteManagerFv = .text:0x80026800; // type:function size:0x4C +fn_80026500__13ActorLightingFv = .text:0x80026500; // type:function size:0x38 +__dt__13ActorLightingFv = .text:0x80026540; // type:function size:0x40 +reset__13ActorLightingFv = .text:0x80026580; // type:function size:0x188 +getLightTev2Color__13ActorLightingFv = .text:0x80026710; // type:function size:0x4C +getLightTev1Color__13ActorLightingFv = .text:0x80026760; // type:function size:0x4C +getLightTev0Color__13ActorLightingFv = .text:0x800267B0; // type:function size:0x4C +getLightTevKColor__13ActorLightingFv = .text:0x80026800; // type:function size:0x4C __sinit_\blur_and_palette_manager_cpp = .text:0x80026850; // type:function size:0x5C scope:local __dt__18dEmitterCallback_cFv = .text:0x800268B0; // type:function size:0xB4 remove__18dEmitterCallback_cFP14dEmitterBase_c = .text:0x80026970; // type:function size:0x88 @@ -10748,7 +10748,7 @@ fn_8019EA70 = .text:0x8019EA70; // type:function size:0x11C fn_8019EB90 = .text:0x8019EB90; // type:function size:0xC fn_8019EBA0 = .text:0x8019EBA0; // type:function size:0x160 fn_8019ED00 = .text:0x8019ED00; // type:function size:0xC -getLightObject = .text:0x8019ED10; // type:function size:0x8 +GetInstance__11dObjLight_cFv = .text:0x8019ED10; // type:function size:0x8 ObjLight__ctor = .text:0x8019ED20; // type:function size:0x30 spawnLightObject = .text:0x8019ED50; // type:function size:0x40 fn_8019ED90 = .text:0x8019ED90; // type:function size:0x884 @@ -10763,10 +10763,10 @@ ObjLight__init = .text:0x801A1F20; // type:function size:0x34 fn_801A1F60 = .text:0x801A1F60; // type:function size:0x138 ObjLight__baseUpdate = .text:0x801A20A0; // type:function size:0x4180 fn_801A6220 = .text:0x801A6220; // type:function size:0x8 -fn_801A6230 = .text:0x801A6230; // type:function size:0x8 -fn_801A6240 = .text:0x801A6240; // type:function size:0x8 -fn_801A6250 = .text:0x801A6250; // type:function size:0x8 -fn_801A6260 = .text:0x801A6260; // type:function size:0x8 +GetColor0x68__11dObjLight_cFv = .text:0x801A6230; // type:function size:0x8 +GetColor0x6C__11dObjLight_cFv = .text:0x801A6240; // type:function size:0x8 +GetColor0x100__11dObjLight_cFv = .text:0x801A6250; // type:function size:0x8 +GetColor0x104__11dObjLight_cFv = .text:0x801A6260; // type:function size:0x8 fn_801A6270 = .text:0x801A6270; // type:function size:0x44 fn_801A62C0 = .text:0x801A62C0; // type:function size:0x58 fn_801A6320 = .text:0x801A6320; // type:function size:0x80 @@ -29955,7 +29955,7 @@ lbl_80500D48 = .data:0x80500D48; // type:object size:0x78 lbl_80500DC0 = .data:0x80500DC0; // type:object size:0x70 lbl_80500E30 = .data:0x80500E30; // type:object size:0x50 __vt__21BlurAndPaletteManager = .data:0x80500E80; // type:object size:0xC -lbl_80500E8C = .data:0x80500E8C; // type:object size:0xC +__vt__13ActorLighting = .data:0x80500E8C; // type:object size:0xC lbl_80500E98 = .data:0x80500E98; // type:object size:0x10 data:string lbl_80500EA8 = .data:0x80500EA8; // type:object size:0x444 __vt__17dMassObjEmitter_c = .data:0x805012EC; // type:object size:0xC @@ -50336,7 +50336,7 @@ lbl_8058F1C8 = .bss:0x8058F1C8; // type:object size:0x28 align:4 data:float lbl_8058F1F0 = .bss:0x8058F1F0; // type:object size:0x20 data:byte lbl_8058F210 = .bss:0x8058F210; // type:object size:0x10 sInstance__21BlurAndPaletteManager = .bss:0x8058F220; // type:object size:0x5D70 -lbl_80594F90 = .bss:0x80594F90; // type:object size:0x10 data:4byte +sList__13ActorLighting = .bss:0x80594F90; // type:object size:0x10 data:4byte sPlayingEffectsList__14dJEffManager_c = .bss:0x80594FA0; // type:object size:0x18 data:4byte sCommonEmitterCallbacks__14dJEffManager_c = .bss:0x80594FB8; // type:object size:0x1C sShpEmitters__14dJEffManager_c = .bss:0x80594FD4; // type:object size:0x1E2C diff --git a/configure.py b/configure.py index 17ee0140..6ce8b885 100644 --- a/configure.py +++ b/configure.py @@ -387,7 +387,7 @@ config.libs = [ Object(NonMatching, "toBeSorted/d_shadow.cpp"), Object(NonMatching, "toBeSorted/d_unk_mdl_stuff_1.cpp"), Object(NonMatching, "toBeSorted/d_unk_mdl_stuff_2.cpp"), - Object(NonMatching, "toBeSorted/blur_and_palette_manager.cpp"), + Object(Matching, "toBeSorted/blur_and_palette_manager.cpp"), Object(NonMatching, "toBeSorted/d_emitter.cpp"), Object(NonMatching, "toBeSorted/d_effects_2.cpp"), Object(NonMatching, "toBeSorted/sound_info.cpp"), @@ -2043,12 +2043,8 @@ config.libs = [ ), Rel(NonMatching, "d_a_obj_evil_field", "REL/d/a/obj/d_a_obj_evil_field.cpp"), Rel(NonMatching, "d_a_obj_F302_light", "REL/d/a/obj/d_a_obj_F302_light.cpp"), - Rel( - Matching, "d_a_obj_F400_gate_leaf", "REL/d/a/obj/d_a_obj_F400_gate_leaf.cpp" - ), - Rel( - Matching, "d_a_obj_F400_gate_seal", "REL/d/a/obj/d_a_obj_F400_gate_seal.cpp" - ), + Rel(Matching, "d_a_obj_F400_gate_leaf", "REL/d/a/obj/d_a_obj_F400_gate_leaf.cpp"), + Rel(Matching, "d_a_obj_F400_gate_seal", "REL/d/a/obj/d_a_obj_F400_gate_seal.cpp"), Rel(NonMatching, "d_a_obj_farmland", "REL/d/a/obj/d_a_obj_farmland.cpp"), Rel(NonMatching, "d_a_obj_fence", "REL/d/a/obj/d_a_obj_fence.cpp"), Rel(Matching, "d_a_obj_fence_boko2", "REL/d/a/obj/d_a_obj_fence_boko2.cpp"), diff --git a/include/d/a/obj/d_a_obj_base.h b/include/d/a/obj/d_a_obj_base.h index c8e1cd80..b611ee54 100644 --- a/include/d/a/obj/d_a_obj_base.h +++ b/include/d/a/obj/d_a_obj_base.h @@ -16,33 +16,7 @@ #include "m/m_mtx.h" #include "m/m_vec.h" #include "m/types_m.h" - -// Ghidra has it as `unk_ActorObjectBase` -struct LightingInfo { - /* 0x00 */ u8 mField_0x00[0x40 - 0x00]; - /* 0x40 */ mColor mTev0Color; - /* 0x44 */ mColor mTev1Color; - /* 0x48 */ mColor mTev2Color; - /* 0x4C */ mColor mTevPrevColor; - /* 0x50 */ mColor mTevK0Color; - /* 0x54 */ mColor mTevK1Color; - /* 0x58 */ mColor mTevK2Color; - /* 0x5C */ mColor mTevK3Color; - /* 0x60 */ u8 mLightingCode; - /* 0x61 */ u8 _0x61; - /* 0x62 */ u8 _0x62; - /* 0x63 */ u8 _0x63; - /* 0x64 */ u8 _0x64; - /* 0x65 */ bool mUseTev0; - /* 0x66 */ bool mUseTev1; - /* 0x67 */ bool mUseTev2; - /* 0x68 */ bool mUseTevPrev; - /* 0x69 */ bool mUseTevK0; - /* 0x6A */ bool mUseTevK1; - /* 0x6B */ bool mUseTevK2; - /* 0x6C */ bool mUseTevK3; - /* 0x6D */ u8 mField_0x69[0x70 - 0x6D]; -}; +#include "toBeSorted/blur_and_palette_manager.h" // Ghidra: ActorObjectBase // size: 0x330 @@ -76,7 +50,7 @@ public: /* 0x208 */ mAng3_c mStartingRot; /* 0x210 */ dLinkage_c mLinkage; /* 0x2B8 */ u32 mField_0x2B8; - /* 0x2BC */ LightingInfo mLightingInfo; + /* 0x2BC */ ActorLighting mLightingInfo; /* 0x32C */ u32 mField_0x32C; public: diff --git a/include/d/d_obj_light.h b/include/d/d_obj_light.h new file mode 100644 index 00000000..bc1065c4 --- /dev/null +++ b/include/d/d_obj_light.h @@ -0,0 +1,51 @@ +#ifndef D_OBJ_LIGHT_H +#define D_OBJ_LIGHT_H + +#include "d/d_base.h" +#include "f/f_base.h" +#include "m/m_color.h" +#include "toBeSorted/d_emitter.h" + +struct UnkLightThing /* : Inheritance Chain TODO */ { + UnkLightThing(); + virtual ~UnkLightThing(); + + /* 0x04 */ u8 _0x04[0x40 - 0x04]; +}; +class dObjLight_c : public dBase_c { +public: + dObjLight_c(); + + virtual ~dObjLight_c() {} + virtual int create() override; + virtual int doDelete() override; + virtual int execute() override; + virtual int draw() override; + +public: + static bool CreateInstance(); + static dObjLight_c *GetInstance(); + + mColor &GetColor0x68(); + mColor &GetColor0x6C(); + mColor &GetColor0x100(); + mColor &GetColor0x104(); + +private: + /* 0x068 */ mColor field_0x68[1][3]; + /* 0x074 */ EffectsStruct mEff; + /* 0x0A8 */ u8 _0xA8[0xB4 - 0xA8]; + /* 0x0B4 */ mColor field_0xB4; + /* 0x0B8 */ u8 _0xB8[0xD0 - 0xB8]; + /* 0x0D0 */ mColor field_0xD0; + /* 0x0D4 */ u8 _0xD4[0x100 - 0xD4]; + /* 0x100 */ mColor field_0x100; + /* 0x104 */ mColor field_0x104; + /* 0x108 */ u8 _0x108[0x10C - 0x108]; + /* 0x10C */ UnkLightThing field_0x10C[8]; + +private: + static dObjLight_c sInstance; +}; + +#endif diff --git a/include/toBeSorted/blur_and_palette_manager.h b/include/toBeSorted/blur_and_palette_manager.h index 76a55292..6f6dc48f 100644 --- a/include/toBeSorted/blur_and_palette_manager.h +++ b/include/toBeSorted/blur_and_palette_manager.h @@ -2,12 +2,63 @@ #define BLUR_AND_PALETTE_MANAGER_H #include "common.h" -#include "egg/math/eggVector.h" #include "m/m_color.h" #include "m/m_vec.h" -#include "rvl/GX/GXTypes.h" #include "toBeSorted/tlist.h" +class ActorLighting { +public: + typedef TList ListType; + /* 0x00 */ TListNode mNode; + static ListType sList; + static void fn_80026500(); + static const mColor &getLightTev2Color(); + static const mColor &getLightTev1Color(); + static const mColor &getLightTev0Color(); + static const mColor &getLightTevKColor(); + +public: + virtual ~ActorLighting(); + + void reset(); + +public: + /* 0x0C */ f32 field_0x0C; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; + /* 0x1C */ f32 field_0x1C; + /* 0x20 */ f32 field_0x20; + /* 0x24 */ f32 field_0x24; + /* 0x28 */ f32 field_0x28; + /* 0x2C */ f32 field_0x2C; + /* 0x30 */ f32 field_0x30; + /* 0x34 */ f32 field_0x34; + /* 0x38 */ f32 field_0x38; + /* 0x3C */ s32 mLightSetIdx; + /* 0x40 */ mColor mTev0Color; + /* 0x44 */ mColor mTev1Color; + /* 0x48 */ mColor mTev2Color; + /* 0x4C */ mColor mTevPrevColor; + /* 0x50 */ mColor mTevK0Color; + /* 0x54 */ mColor mTevK1Color; + /* 0x58 */ mColor mTevK2Color; + /* 0x5C */ mColor mTevK3Color; + /* 0x60 */ u8 mLightingCode; + /* 0x61 */ u8 field_0x61; + /* 0x62 */ u8 field_0x62; + /* 0x63 */ u8 field_0x63; + /* 0x64 */ u8 field_0x64; + /* 0x65 */ bool mUseTev0; + /* 0x66 */ bool mUseTev1; + /* 0x67 */ bool mUseTev2; + /* 0x68 */ bool mUseTevPrev; + /* 0x69 */ bool mUseTevK0; + /* 0x6A */ bool mUseTevK1; + /* 0x6B */ bool mUseTevK2; + /* 0x6C */ bool mUseTevK3; +}; + struct LIGHT_INFLUENCE { void SetColor(mColor clr) { mClr = clr; @@ -28,21 +79,6 @@ struct LIGHT_INFLUENCE { /* 0x18 */ bool field_0x18; }; -struct UnkBlurPaletteListNode { - TListNode mNode; -}; - -struct SffSub { - mColor field_0x00; - f32 field_0x04; - f32 field_0x08; -}; - -struct SpfSub2 { - mColor field_0x00; - u8 field_0x04[5]; -}; - // This is a weird one - mColor / nw4r::ut::Color are assumed // to be 4-byte-aligned so that all the u32 type punning works // correctly, but field_0x1D5 is unaligned and uses a separate @@ -74,117 +110,137 @@ struct TwoPaletteDefaultMCF { /* 0x20 */ PaletteDefaultMCF field_0x20; }; -// Ghidra had contents of this in an array but that won't work due to dtor codegen. -// Start is correct (dtor offset), needs to at least include field_0x104 -struct SpfSub { - /* 0x000 */ f32 field_0x000; - /* 0x004 */ mColor grey_787878; - /* 0x008 */ SffSub white3_ffffff; - /* 0x014 */ SpfSub2 field_0x014; +struct ActorPalette { + /* 0x000 */ mColor mAmbientClr; + /* 0x004 */ mColor mDiffuseClr; + /* 0x008 */ mColor mBrightnessClr; + /* 0x00C */ mColor mSpecularClr; + /* 0x010 */ mColor mDarkShadowClr; + /* 0x014 */ mColor mDarkLightClr; + /* 0x018 */ f32 mSpecular; + /* 0x01C */ mColor field_0x01C; + /* 0x020 */ f32 mTemperature; // -1 cool, 1 warm + /* 0x024 */ f32 field_0x24; + /* 0x028 */ mColor mShadowClr; + /* 0x02C */ mColor field_0x02C; +}; + +struct StagePalette { + /* 0x000 */ f32 mBrightness; + /* 0x004 */ mColor mShadowClr; + /* 0x008 */ mColor mLightClr; + /* 0x00C */ f32 mSunMoonAngle1; + /* 0x010 */ f32 mSunMoonAngle2; + + /* 0x014 */ mColor field_0x014; + /* 0x018 */ u8 field_0x018[5]; /* 0x020 */ mColor field_0x020[5]; /* 0x034 */ f32 field_0x034[5]; /* 0x048 */ f32 field_0x048[5]; + /* 0x05C */ f32 field_0x05C; - /* 0x060 */ SpfSub2 field_0x060; + /* 0x060 */ mColor field_0x060; + /* 0x064 */ u8 field_0x064[5]; /* 0x06C */ mColor field_0x06C[5]; /* 0x080 */ f32 field_0x080[5]; /* 0x094 */ f32 field_0x094[5]; + /* 0x0A8 */ f32 field_0x0A8; - /* 0x0AC */ SpfSub2 field_0x0AC; + /* 0x0AC */ mColor field_0x0AC; + /* 0x0B0 */ u8 field_0x0B0[5]; /* 0x0B8 */ mColor field_0x0B8[5]; /* 0x0CC */ f32 field_0x0CC[5]; /* 0x0E0 */ f32 field_0x0E0[5]; + /* 0x0F4 */ f32 field_0x0F4; - /* 0x0F8 */ SpfSub2 field_0x0F8; + /* 0x0F8 */ mColor field_0x0F8; + /* 0x0FC */ u8 field_0x0FC[5]; /* 0x104 */ mColor field_0x104[5]; /* 0x118 */ f32 field_0x118[5]; /* 0x12C */ f32 field_0x12C[5]; }; -// We assume there's SffSub in here because of weak function order -// The size is correct now, but the default assignment operator doesn't match yet, -// which could have many reasons. Need to tweak the layout. -struct Spf { - Spf(); - ~Spf() {} +struct SkyPalette { + /* 0x000 */ mColor field_0x00; + /* 0x004 */ mColor field_0x04; + /* 0x008 */ mColor field_0x08; + /* 0x00C */ mColor mCloudColor; + /* 0x010 */ mColor mSkyColor; + /* 0x014 */ mColor field_0x14; + /* 0x018 */ mColor mSkyFilter; + /* 0x01C */ mVec3_c mSkyCenter; + /* 0x028 */ mVec3_c mSkyScale; +}; - /* 0x000 */ mColor grey_aaaaaa; - /* 0x004 */ mColor white_ffffff; - /* 0x008 */ mColor grey_808080; - /* 0x00C */ mColor cream_ffffc0; - /* 0x010 */ mColor grey2_aaaaaa; - /* 0x014 */ mColor white2_ffffff; - /* 0x018 */ f32 field_0x18; - /* 0x01C */ mColor pastel_orange_ffb787; - /* 0x020 */ f32 field_0x20; - /* 0x024 */ f32 field_0x24; - /* 0x028 */ mColor black_000000; - /* 0x02C */ mColor black2_000000; - /* 0x030 */ SpfSub mSub; - /* 0x170 */ mColor grey_787878; - /* 0x174 */ mColor grey2_787878; - /* 0x178 */ mColor grey3_787878; - /* 0x17C */ mColor mCloudColor; - /* 0x180 */ mColor mSkyColor; - /* 0x184 */ mColor seafoam_green_b9d8b7; - /* 0x188 */ mColor white3_ffffff; - /* 0x18C */ mVec3_c field_0x18C; - /* 0x198 */ mVec3_c field_0x198; - /* 0x1A4 */ SffSub MAO5_kColor3; // assuming SffSub here due to initialization with same values - /* 0x1B0 */ mVec3_c field_0x1B0; - /* 0x1BC */ u8 field_0x1BC; - /* 0x1C0 */ f32 field_0x1C0; - /* 0x1C4 */ f32 field_0x1C4; - /* 0x1C8 */ u8 field_0x1C8; - /* 0x1CC */ f32 field_0x1CC; - /* 0x1D0 */ f32 field_0x1D0; - /* 0x1D4 */ u8 field_0x1D4; - /* 0x1D5 */ UnalignedColor field_0x1D5; // pastel_yelow_#fff0b4 - /* 0x1D9 */ u8 field_0x1D9; - /* 0x1DC */ f32 field_0x1DC; - /* 0x1E0 */ f32 field_0x1E0; - /* 0x1E4 */ f32 field_0x1E4; - /* 0x1E8 */ f32 field_0x1E8; - /* 0x1EC */ u8 field_0x1EC; - /* 0x1ED */ u8 field_0x1ED; - /* 0x1EE */ u16 field_0x1EE; - /* 0x1F0 */ f32 field_0x1F0; - /* 0x1F4 */ f32 field_0x1F4; - /* 0x1F8 */ f32 field_0x1F8; - /* 0x1FC */ f32 field_0x1FC; - /* 0x200 */ mColor black3_000000; - /* 0x204 */ mColor black4_000000; +struct SffSub { + mColor field_0x00; + f32 field_0x04; + f32 field_0x08; +}; + +struct SpfSubUnk0 { + /* 0x00 */ SffSub field_0x00; + /* 0x0C */ f32 field_0x0C[3]; +}; + +struct SpfSubUnk1 { + /* 0x00 */ u8 field_0x00; + /* 0x04 */ f32 field_0x04; + /* 0x08 */ f32 field_0x08; + /* 0x0C */ u8 field_0x0C; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ u8 field_0x18; + /* 0x19 */ UnalignedColor field_0x19; // Bloom Color + /* 0x1D */ u8 field_0x1D; +}; + +struct SpfSubUnk2 { + /* 0x00 */ f32 field_0x00; // Blur Dist + /* 0x04 */ f32 field_0x04; // Blur Diffuse + /* 0x08 */ f32 field_0x08; // Softness Distance + /* 0x0C */ f32 field_0x0C; // Softness diffuse + /* 0x10 */ u8 field_0x10; + /* 0x11 */ u8 field_0x11; // Turning this to not 0 disables effects + /* 0x12 */ u16 field_0x12; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; + /* 0x1C */ f32 field_0x1C; // Blur? + /* 0x20 */ f32 field_0x20; // Fog? Shadow? +}; + +// Broken up in a way to get the assignment operator to match. +// Not 100% certain +struct Spf { + /* 0x000 */ ActorPalette mActorPalette; + /* 0x030 */ StagePalette mStagePalette; + /* 0x170 */ SkyPalette mSkyPalette; + /* 0x1A4 */ SpfSubUnk0 field_0x1A4; + /* 0x1BC */ SpfSubUnk1 field_0x1BC; + /* 0x1DC */ SpfSubUnk2 field_0x1D4; + /* 0x200 */ mColor mParticleTransparentClr; + /* 0x204 */ mColor mParticleSolidClr; }; struct Sff { - Sff(); - ~Sff() {} - SffSub field_0x00[3]; }; struct EFLIGHT_PROC { - EFLIGHT_PROC() {} - ~EFLIGHT_PROC() {} - /* 0x00 */ u8 mState; /* 0x01 */ u8 mFrame; /* 0x04 */ int mLightType; /* 0x08 */ LIGHT_INFLUENCE field_0x8; }; -struct Bpm2 { - Bpm2() {} - ~Bpm2() {} - - /* 0x00 */ mVec3_c mPosition; - /* 0x0C */ u32 field_0x0C; +// Deals with the direction wind particles go? +struct WIND_INFLUENCE { + /* 0x00 */ mVec3_c mVel; + /* 0x0C */ f32 field_0x0C; /* 0x10 */ f32 field_0x10; }; struct PaletteEAF_smol_entry { - PaletteEAF_smol_entry() {} - ~PaletteEAF_smol_entry() {} mColor field_0x00; mColor field_0x04; mColor field_0x08; @@ -192,13 +248,10 @@ struct PaletteEAF_smol_entry { }; struct PaletteEAF_smol { - ~PaletteEAF_smol() {} PaletteEAF_smol_entry field_0x00[8]; }; struct PaletteEAF_big_entry { - PaletteEAF_big_entry() {} - ~PaletteEAF_big_entry() {} mColor field_0x00; mColor field_0x04; mColor field_0x08; @@ -207,55 +260,59 @@ struct PaletteEAF_big_entry { }; struct PaletteEAF_big { - ~PaletteEAF_big() {} PaletteEAF_big_entry field_0x00[8]; }; // Apparently particle color related struct Bpm3 { - Bpm3() {} - ~Bpm3() {} - PaletteEAF_smol field_0x00[0x20]; }; struct Bpm4 { - Bpm4() {} - ~Bpm4() {} - PaletteEAF_big field_0x00[0x20]; }; struct SHADOW_INFLUENCE { - SHADOW_INFLUENCE() {} - ~SHADOW_INFLUENCE() {} - /* 0x00 */ mVec3_c mPos; /* 0x0C */ f32 mRadius; /* 0x10 */ s16 mIdx; }; struct Bpm8 { - Bpm8() {} - ~Bpm8() {} - /* 0x00 */ mVec3_c mPos; - /* 0x0C */ f32 field_0x0C; + /* 0x0C */ f32 mRadius; /* 0x10 */ s32 field_0x10; }; struct Bpm9 { - Bpm9() {} - ~Bpm9() {} + /* 0x00 */ bool field_0x00; + /* 0x04 */ mVec3_c mPos; + /* 0x10 */ f32 mRadius; +}; - u8 _0x00[0x14 - 0x00]; +struct Mist { + /* 0x00 */ u8 mMode; + /* 0x01 */ u8 mDecay; + /* 0x02 */ u8 mAlpha; + /* 0x04 */ f32 mDirection; + /* 0x08 */ f32 mSpeed; +}; + +struct SpfSetting { + s16 mIdxStart; + s16 mIdxEnd; + f32 mRatio; +}; + +struct SpfTransitionSetting { + s16 mIdxBefore; + s16 mIdxAfter; + s32 mNumFrames; }; class BlurAndPaletteManager { public: BlurAndPaletteManager(); - virtual ~BlurAndPaletteManager() { - sPInstance = nullptr; - } + virtual ~BlurAndPaletteManager(); static BlurAndPaletteManager &GetInstance() { return sInstance; @@ -286,25 +343,69 @@ public: void setLightFilter(f32 ratio); void set0x35B0(f32 f); - void fn_800247D0(mVec3_c, f32); + // Params are guesses + void setBPM8(const mVec3_c *pos, u32 type, f32 radius); + void setBPM8_Type4(const mVec3_c *pos); + void setBPM8_Type6(const mVec3_c *pos); + void setBPM8_Type10(const mVec3_c *pos); + void setBPM8_Type10_2(const mVec3_c *pos); + void setBPM8_Type6_2(const mVec3_c *pos); + bool check_BPM8(const mVec3_c *pos, mVec3_c *pOutPos); + bool check_BPM8_1001(const mVec3_c *pos, mVec3_c *pOutPos); + bool check_BPM8_501(const mVec3_c *pos, mVec3_c *pOutPos); + + bool setUnk(const mVec3_c *pos, f32 radius); + void setBPM9(const mVec3_c *pos, f32 radius); + bool check_BPM9(const mVec3_c *pos); + + s32 checkBPM9_Entity(mVec3_c *pOutPos); + + void setAlterateRoomId(s32 roomId); + s32 getAlterateRoomId(); + + mColor color_ratio_set(const mColor &start, const mColor &end, f32 ratio); + mVec3_c vec_ratio_set(const mVec3_c &start, const mVec3_c &end, f32 ratio); + f32 f32_ratio_set(const f32 start, const f32 end, f32 ratio); + u16 u16_ratio_set(const u16 start, const u16 end, f32 ratio); + u8 u8_ratio_set(const u8 start, const u8 end, f32 ratio); + + void spf_ratio_set(Spf &out, const Spf &start, const Spf &end, f32 ratio); + void light_influence_ratio_set( + LIGHT_INFLUENCE &out, const LIGHT_INFLUENCE &start, const LIGHT_INFLUENCE &end, f32 ratio + ); + void sff_ratio_set(Sff &out, const Sff &start, const Sff &end, f32 ratio); + + void set_override_spf(s16 start, s16 end, f32 ratio); + + void setMist(u8 mode, u8 decay, u8 alpha, f32 dir, f32 speed); + void setMistMode3(const mVec3_c &vel, f32 value); + + void setDOF(f32 dof); + void disableDOF(); + + void setWind(mVec3_c mPos, f32 f); + void setField_0x2F20(f32 arg) { field_0x2F20 = arg; } // light pillar related - void fn_80024240(s16, s16, s16); - bool fn_80024770(int); - bool fn_800247A0(int); + void set_palette_transition(s16 before, s16 after, s32 numFrames); + + // All related + void fn_80024740(u8, u8); + bool fn_80024770(u8); + bool fn_800247A0(u8); u8 get0x2DE8() const { - return field_0x2DE0[8]; + return field_0x2DE8[0]; } const PaletteDefaultMCF &GetCurrentDefaultMcf() const { return field_0x5CE4; } - const Spf &GetCurrentSph() const { + const Spf &GetCurrentSpf() const { return currentSpf; } @@ -324,22 +425,24 @@ public: return field_0x2F1C; } - static mColor &getLightColor1(); - static mColor &getLightColor2(); - private: - mColor combineColors(const mColor &c1, const mColor &c2, f32 ratio); - /* 0x0004 */ Spf currentSpf; /* 0x020C */ Spf spfs[20]; /* 0x2AAC */ Sff currentSff; /* 0x2AD0 */ Sff sffs[20]; - /* 0x2DA0 */ u8 field_0x2DA0[0x2DD4 - 0x2DA0]; - /* 0x2DD4 */ mVec3_c field_0x2DD4; - /* 0x2DE0 */ u8 field_0x2DE0[0x2DEC - 0x2DE0]; + /* 0x2DA0 */ SpfSetting mCurrentSpfSetting; + /* 0x2DA8 */ u8 field_0x2DA8[0x2DB4 - 0x2DA8]; + /* 0x2DB4 */ SpfTransitionSetting mTransitionSpfSetting; + /* 0x2DBC */ u8 field_0x2DBC[0x2DC0 - 0x2DBC]; + /* 0x2DC0 */ SpfSetting mOverrideSpfSetting; + /* 0x2DC8 */ Mist mMistInfo; + /* 0x2DD4 */ mVec3_c mMistPos; + /* 0x2DE0 */ bool mDofEnabled; + /* 0x2DE4 */ f32 mDof; + /* 0x2DE8 */ u8 field_0x2DE8[0x2DEC - 0x2DE8]; /* 0x2DEC */ mColor field_0x2DEC; /* 0x2DF0 */ u8 field_0x2DF0[0x2DF4 - 0x2DF0]; - /* 0x2DF4 */ mColor field_0x2DF4; // Controls Light filtering + /* 0x2DF4 */ mColor field_0x2DF4; /* 0x2DF8 */ mVec3_c field_0x2DF8; /* 0x2E04 */ u8 field_0x2E04[0x2E08 - 0x2E04]; /* 0x2E08 */ mVec3_c field_0x2E08[5]; @@ -361,19 +464,30 @@ private: /* 0x2F3C */ LIGHT_INFLUENCE *pointlight[200]; /* 0x325C */ SHADOW_INFLUENCE *pshadow[200]; /* 0x357C */ EFLIGHT_PROC eflight; - /* 0x35A0 */ Bpm2 field_0x35A0; + /* 0x35A0 */ WIND_INFLUENCE mWind; /* 0x35B4 */ SHADOW_INFLUENCE field_0x35B4[8]; /* 0x3654 */ Bpm8 field_0x3654[10]; /* 0x371C */ Bpm9 field_0x371C[20]; - /* 0x38AC */ u8 _0x38AC[0x38B4 - 0x38AC]; + /* 0x387C */ u32 field_0x387C; + /* 0x38B0 */ bool field_0x38B0; /* 0x38B4 */ mVec3_c field_0x38B4; - /* 0x38C0 */ u8 _0x38C0[0x38C8 - 0x38C0]; + /* 0x38C0 */ f32 field_0x38C0; + /* 0x38C4 */ s32 field_0x38C4; /* 0x38C8 */ mVec3_c field_0x38C8; - /* 0x38D4 */ u8 _0x38D4[0x38E4 - 0x38D4]; + /* 0x38D4 */ u32 mPlayerRoomId; + /* 0x38D8 */ s32 mAlternateRoomId; + /* 0x38D8 */ u32 field_0x38DC; + /* 0x38D8 */ s32 field_0x38E0; /* 0x38E4 */ Bpm3 field_0x38E4; /* 0x48E4 */ Bpm4 field_0x48E4; /* 0x5CE4 */ PaletteDefaultMCF field_0x5CE4; /* 0x5D04 */ TwoPaletteDefaultMCF field_0x5D04; + /* 0x5D44 */ u8 field_0x5D44[0x5D59 - 0x5D44]; + /* 0x5D5A */ struct { // Anonymous until more is known + bool mEnabled; + u8 mValue; + } field_0x5D59[9]; + /* 0x5D60 */ u8 field_0x5D6C[0x5D70 - 0x5D6C]; static BlurAndPaletteManager sInstance; static BlurAndPaletteManager *sPInstance; diff --git a/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp b/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp index 52890a43..58860170 100644 --- a/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp +++ b/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp @@ -22,7 +22,6 @@ #include "toBeSorted/dowsing_target.h" #include "toBeSorted/small_sound_mgr.h" - void float_ordering() { const f32 arr[] = {5.f, 15.f, 7.f, 0.5f, 0.1f}; } @@ -106,7 +105,7 @@ int dAcOTumbleWeed_c::actorExecute() { calcWind(); sLib::chase(&mField_0x980, 1.f, 0.1f); - BlurAndPaletteManager::GetInstance().fn_800247D0(mField_0x968, mField_0x980); + BlurAndPaletteManager::GetInstance().setWind(mField_0x968, mField_0x980); calcVelocity(); position += velocity; diff --git a/src/d/d_message.cpp b/src/d/d_message.cpp index 83add314..ffe13805 100644 --- a/src/d/d_message.cpp +++ b/src/d/d_message.cpp @@ -496,7 +496,7 @@ bool dFlow_c::handleEventInternal(const MsbFlowInfo *element) { s16 p1 = (params1n2 >> 16) & 0xFFFF; s16 p2 = params1n2 & 0xFFFF; if (&BlurAndPaletteManager::GetInstance() != nullptr) { - BlurAndPaletteManager::GetInstance().fn_80024240(-1, p1, p2); + BlurAndPaletteManager::GetInstance().set_palette_transition(-1, p1, p2); } break; } diff --git a/src/toBeSorted/blur_and_palette_manager.cpp b/src/toBeSorted/blur_and_palette_manager.cpp index d6a4f53d..d880f502 100644 --- a/src/toBeSorted/blur_and_palette_manager.cpp +++ b/src/toBeSorted/blur_and_palette_manager.cpp @@ -1,7 +1,12 @@ + #include "toBeSorted/blur_and_palette_manager.h" #include "common.h" +#include "d/a/d_a_itembase.h" #include "d/a/d_a_player.h" +#include "d/d_obj_light.h" +#include "d/d_sc_game.h" +#include "d/flag/itemflag_manager.h" #include "m/m_color.h" #include "m/m_vec.h" #include "nw4r/math/math_arithmetic.h" @@ -9,7 +14,7 @@ BlurAndPaletteManager BlurAndPaletteManager::sInstance; BlurAndPaletteManager *BlurAndPaletteManager::sPInstance; -TList sPlayingEffectsList; +ActorLighting::ListType ActorLighting::sList; // Same as vectle_calc in d_kankyo_rain from tp static void vectle_calc(const mVec3_c *pIn, mVec3_c *pOut) { @@ -258,22 +263,465 @@ void BlurAndPaletteManager::setLightFilter(f32 ratio) { field_0x2DF4.b = ratio * 255.f; } void BlurAndPaletteManager::set0x35B0(f32 f) { - field_0x35A0.field_0x10 = f; + mWind.field_0x10 = f; } -mColor BlurAndPaletteManager::combineColors(const mColor &c1, const mColor &c2, f32 ratio) { +void BlurAndPaletteManager::setBPM8(const mVec3_c *pos, u32 type, f32 radius) { + for (int i = 0; i < 10; ++i) { + if (field_0x3654[i].field_0x10 <= -1) { + field_0x3654[i].mPos = *pos; + field_0x3654[i].mRadius = radius; + field_0x3654[i].field_0x10 = type; + return; + } + } +} + +void BlurAndPaletteManager::setBPM8_Type4(const mVec3_c *pos) { + setBPM8(pos, 4, 250.f); +} + +void BlurAndPaletteManager::setBPM8_Type6(const mVec3_c *pos) { + setBPM8(pos, 6, 500.f); +} + +void BlurAndPaletteManager::setBPM8_Type10(const mVec3_c *pos) { + setBPM8(pos, 10, 1000.f); +} + +void BlurAndPaletteManager::setBPM8_Type10_2(const mVec3_c *pos) { + setBPM8(pos, 10, 1001.f); +} + +void BlurAndPaletteManager::setBPM8_Type6_2(const mVec3_c *pos) { + setBPM8(pos, 6, 501.f); +} + +bool BlurAndPaletteManager::check_BPM8(const mVec3_c *pos, mVec3_c *pOutPos) { + bool ret = false; + for (int i = 0; i < 10; ++i) { + if (field_0x3654[i].field_0x10 > 0) { + if (pos->distance(field_0x3654[i].mPos) <= field_0x3654[i].mRadius) { + ret = true; + if (pOutPos) { + *pOutPos = field_0x3654[i].mPos; + } + break; + } + } + } + return ret; +} + +bool BlurAndPaletteManager::check_BPM8_1001(const mVec3_c *pos, mVec3_c *pOutPos) { + bool ret = false; + for (int i = 0; i < 10; ++i) { + if (field_0x3654[i].field_0x10 > 0) { + if (pos->distance(field_0x3654[i].mPos) <= field_0x3654[i].mRadius && field_0x3654[i].mRadius == 1001.f) { + ret = true; + if (pOutPos) { + *pOutPos = field_0x3654[i].mPos; + } + break; + } + } + } + return ret; +} + +bool BlurAndPaletteManager::check_BPM8_501(const mVec3_c *pos, mVec3_c *pOutPos) { + bool ret = false; + for (int i = 0; i < 10; ++i) { + if (field_0x3654[i].field_0x10 > 0) { + if (pos->distance(field_0x3654[i].mPos) <= field_0x3654[i].mRadius && field_0x3654[i].mRadius == 501.f) { + ret = true; + if (pOutPos) { + *pOutPos = field_0x3654[i].mPos; + } + break; + } + } + } + return ret; +} + +bool BlurAndPaletteManager::setUnk(const mVec3_c *pos, f32 radius) { + bool ret = false; + if (field_0x38B0 == false) { + field_0x38B0 = true; + field_0x38B4 = *pos; + field_0x38C0 = radius; + ret = true; + } + + return ret; +} + +void BlurAndPaletteManager::setBPM9(const mVec3_c *pos, f32 radius) { + for (int i = 0; i < 20; ++i) { + if (field_0x371C[i].field_0x00 == false) { + field_0x371C[i].field_0x00 = true; + field_0x371C[i].mPos = *pos; + field_0x371C[i].mRadius = radius; + return; + } + } +} + +bool BlurAndPaletteManager::check_BPM9(const mVec3_c *pos) { + bool ret = false; + for (int i = 0; i < 20; ++i) { + if (field_0x371C[i].field_0x00) { + if (pos->distance(field_0x371C[i].mPos) <= field_0x371C[i].mRadius) { + ret = true; + break; + } + } + } + return ret; +} + +s32 BlurAndPaletteManager::checkBPM9_Entity(mVec3_c *pos) { + s32 value = field_0x38C4; + if (value != 0 && pos != nullptr) { + *pos = field_0x38C8; + } + return value; +} + +void BlurAndPaletteManager::setAlterateRoomId(s32 roomId) { + mAlternateRoomId = roomId; +} + +s32 BlurAndPaletteManager::getAlterateRoomId() { + return mAlternateRoomId; +} + +mColor BlurAndPaletteManager::color_ratio_set(const mColor &start, const mColor &end, f32 ratio) { mColor result; result.Set(0xff, 0xff, 0xff, 0xff); - result.r = (c1.r + ratio * ((f32)c2.r - (f32)c1.r)); - result.g = (c1.g + ratio * ((f32)c2.g - (f32)c1.g)); - result.b = (c1.b + ratio * ((f32)c2.b - (f32)c1.b)); - result.a = (c1.a + ratio * ((f32)c2.a - (f32)c1.a)); + result.r = (start.r + ratio * ((f32)end.r - (f32)start.r)); + result.g = (start.g + ratio * ((f32)end.g - (f32)start.g)); + result.b = (start.b + ratio * ((f32)end.b - (f32)start.b)); + result.a = (start.a + ratio * ((f32)end.a - (f32)start.a)); return result; } -Spf::Spf() {} +mVec3_c BlurAndPaletteManager::vec_ratio_set(const mVec3_c &start, const mVec3_c &end, f32 ratio) { + mVec3_c result; + result.x = start.x + ratio * (end.x - start.x); + result.y = start.y + ratio * (end.y - start.y); + result.z = start.z + ratio * (end.z - start.z); + return result; +} -Sff::Sff() {} +f32 BlurAndPaletteManager::f32_ratio_set(const f32 start, const f32 end, f32 ratio) { + return start + ratio * (end - start); +} + +u16 BlurAndPaletteManager::u16_ratio_set(const u16 start, const u16 end, f32 ratio) { + return (f32)start + ratio * ((f32)end - (f32)start); +} + +u8 BlurAndPaletteManager::u8_ratio_set(const u8 start, const u8 end, f32 ratio) { + return static_cast((f32)start + ratio * (f32)(end - (f32)start)) & 0xFF; +} + +void BlurAndPaletteManager::spf_ratio_set(Spf &out, const Spf &start, const Spf &end, f32 ratio) { + mColor black0; + mColor black1; + out.mActorPalette.mAmbientClr = + color_ratio_set(start.mActorPalette.mAmbientClr, end.mActorPalette.mAmbientClr, ratio); + out.mActorPalette.mDiffuseClr = + color_ratio_set(start.mActorPalette.mDiffuseClr, end.mActorPalette.mDiffuseClr, ratio); + out.mActorPalette.mBrightnessClr = + color_ratio_set(start.mActorPalette.mBrightnessClr, end.mActorPalette.mBrightnessClr, ratio); + out.mActorPalette.mSpecularClr = + color_ratio_set(start.mActorPalette.mSpecularClr, end.mActorPalette.mSpecularClr, ratio); + out.mActorPalette.mDarkShadowClr = + color_ratio_set(start.mActorPalette.mDarkShadowClr, end.mActorPalette.mDarkShadowClr, ratio); + out.mActorPalette.mDarkLightClr = + color_ratio_set(start.mActorPalette.mDarkLightClr, end.mActorPalette.mDarkLightClr, ratio); + + out.mActorPalette.mSpecular = f32_ratio_set(start.mActorPalette.mSpecular, end.mActorPalette.mSpecular, ratio); + out.mActorPalette.field_0x01C = + color_ratio_set(start.mActorPalette.field_0x01C, end.mActorPalette.field_0x01C, ratio); + out.mActorPalette.mTemperature = + f32_ratio_set(start.mActorPalette.mTemperature, end.mActorPalette.mTemperature, ratio); + out.mActorPalette.field_0x24 = f32_ratio_set(start.mActorPalette.field_0x24, end.mActorPalette.field_0x24, ratio); + + black0 = start.mActorPalette.mShadowClr; + black1 = end.mActorPalette.mShadowClr; + if (black0.a == 0) { + black0.Set(0, 0, 0x1E, 0xC8); + } + if (black1.a == 0) { + black1.Set(0, 0, 0x1E, 0xC8); + } + + out.mActorPalette.mShadowClr = color_ratio_set(black0, black1, ratio); + out.mActorPalette.field_0x02C = + color_ratio_set(start.mActorPalette.field_0x02C, end.mActorPalette.field_0x02C, ratio); + + out.mStagePalette.mBrightness = + f32_ratio_set(start.mStagePalette.mBrightness, end.mStagePalette.mBrightness, ratio); + out.mStagePalette.mShadowClr = color_ratio_set(start.mStagePalette.mShadowClr, end.mStagePalette.mShadowClr, ratio); + out.mStagePalette.mLightClr = color_ratio_set(start.mStagePalette.mLightClr, end.mStagePalette.mLightClr, ratio); + out.mStagePalette.mSunMoonAngle1 = + f32_ratio_set(start.mStagePalette.mSunMoonAngle1, end.mStagePalette.mSunMoonAngle1, ratio); + out.mStagePalette.mSunMoonAngle2 = + f32_ratio_set(start.mStagePalette.mSunMoonAngle2, end.mStagePalette.mSunMoonAngle2, ratio); + + out.mStagePalette.field_0x014 = + color_ratio_set(start.mStagePalette.field_0x014, end.mStagePalette.field_0x014, ratio); + + for (int i = 0; i < 5; ++i) { + out.mStagePalette.field_0x018[i] = + u8_ratio_set(start.mStagePalette.field_0x018[i], end.mStagePalette.field_0x018[i], ratio); + out.mStagePalette.field_0x020[i] = + color_ratio_set(start.mStagePalette.field_0x020[i], end.mStagePalette.field_0x020[i], ratio); + out.mStagePalette.field_0x034[i] = + f32_ratio_set(start.mStagePalette.field_0x034[i], end.mStagePalette.field_0x034[i], ratio); + out.mStagePalette.field_0x048[i] = + f32_ratio_set(start.mStagePalette.field_0x048[i], end.mStagePalette.field_0x048[i], ratio); + } + + out.mStagePalette.field_0x05C = + f32_ratio_set(start.mStagePalette.field_0x05C, end.mStagePalette.field_0x05C, ratio); + out.mStagePalette.field_0x060 = + color_ratio_set(start.mStagePalette.field_0x060, end.mStagePalette.field_0x060, ratio); + + for (int i = 0; i < 5; ++i) { + out.mStagePalette.field_0x064[i] = + u8_ratio_set(start.mStagePalette.field_0x064[i], end.mStagePalette.field_0x064[i], ratio); + out.mStagePalette.field_0x06C[i] = + color_ratio_set(start.mStagePalette.field_0x06C[i], end.mStagePalette.field_0x06C[i], ratio); + out.mStagePalette.field_0x080[i] = + f32_ratio_set(start.mStagePalette.field_0x080[i], end.mStagePalette.field_0x080[i], ratio); + out.mStagePalette.field_0x094[i] = + f32_ratio_set(start.mStagePalette.field_0x094[i], end.mStagePalette.field_0x094[i], ratio); + } + + out.mStagePalette.field_0x0A8 = + f32_ratio_set(start.mStagePalette.field_0x0A8, end.mStagePalette.field_0x0A8, ratio); + out.mStagePalette.field_0x0AC = + color_ratio_set(start.mStagePalette.field_0x0AC, end.mStagePalette.field_0x0AC, ratio); + + for (int i = 0; i < 5; ++i) { + out.mStagePalette.field_0x0B0[i] = + u8_ratio_set(start.mStagePalette.field_0x0B0[i], end.mStagePalette.field_0x0B0[i], ratio); + out.mStagePalette.field_0x0B8[i] = + color_ratio_set(start.mStagePalette.field_0x0B8[i], end.mStagePalette.field_0x0B8[i], ratio); + out.mStagePalette.field_0x0CC[i] = + f32_ratio_set(start.mStagePalette.field_0x0CC[i], end.mStagePalette.field_0x0CC[i], ratio); + out.mStagePalette.field_0x0E0[i] = + f32_ratio_set(start.mStagePalette.field_0x0E0[i], end.mStagePalette.field_0x0E0[i], ratio); + } + + out.mStagePalette.field_0x0F4 = + f32_ratio_set(start.mStagePalette.field_0x0F4, end.mStagePalette.field_0x0F4, ratio); + out.mStagePalette.field_0x0F8 = + color_ratio_set(start.mStagePalette.field_0x0F8, end.mStagePalette.field_0x0F8, ratio); + + for (int i = 0; i < 5; ++i) { + out.mStagePalette.field_0x0FC[i] = + u8_ratio_set(start.mStagePalette.field_0x0FC[i], end.mStagePalette.field_0x0FC[i], ratio); + out.mStagePalette.field_0x104[i] = + color_ratio_set(start.mStagePalette.field_0x104[i], end.mStagePalette.field_0x104[i], ratio); + out.mStagePalette.field_0x118[i] = + f32_ratio_set(start.mStagePalette.field_0x118[i], end.mStagePalette.field_0x118[i], ratio); + out.mStagePalette.field_0x12C[i] = + f32_ratio_set(start.mStagePalette.field_0x12C[i], end.mStagePalette.field_0x12C[i], ratio); + } + + out.mSkyPalette.field_0x00 = color_ratio_set(start.mSkyPalette.field_0x00, end.mSkyPalette.field_0x00, ratio); + out.mSkyPalette.field_0x04 = color_ratio_set(start.mSkyPalette.field_0x04, end.mSkyPalette.field_0x04, ratio); + out.mSkyPalette.field_0x08 = color_ratio_set(start.mSkyPalette.field_0x08, end.mSkyPalette.field_0x08, ratio); + out.mSkyPalette.mCloudColor = color_ratio_set(start.mSkyPalette.mCloudColor, end.mSkyPalette.mCloudColor, ratio); + out.mSkyPalette.mSkyColor = color_ratio_set(start.mSkyPalette.mSkyColor, end.mSkyPalette.mSkyColor, ratio); + out.mSkyPalette.field_0x14 = color_ratio_set(start.mSkyPalette.field_0x14, end.mSkyPalette.field_0x14, ratio); + out.mSkyPalette.mSkyFilter = color_ratio_set(start.mSkyPalette.mSkyFilter, end.mSkyPalette.mSkyFilter, ratio); + out.mSkyPalette.mSkyCenter = vec_ratio_set(start.mSkyPalette.mSkyCenter, end.mSkyPalette.mSkyCenter, ratio); + out.mSkyPalette.mSkyScale = vec_ratio_set(start.mSkyPalette.mSkyScale, end.mSkyPalette.mSkyScale, ratio); + + out.field_0x1A4.field_0x00.field_0x00 = + color_ratio_set(start.field_0x1A4.field_0x00.field_0x00, end.field_0x1A4.field_0x00.field_0x00, ratio); + out.field_0x1A4.field_0x00.field_0x04 = + f32_ratio_set(start.field_0x1A4.field_0x00.field_0x04, end.field_0x1A4.field_0x00.field_0x04, ratio); + out.field_0x1A4.field_0x00.field_0x08 = + f32_ratio_set(start.field_0x1A4.field_0x00.field_0x08, end.field_0x1A4.field_0x00.field_0x08, ratio); + + out.field_0x1A4.field_0x0C[0] = + f32_ratio_set(start.field_0x1A4.field_0x0C[0], end.field_0x1A4.field_0x0C[0], ratio); + out.field_0x1A4.field_0x0C[1] = + f32_ratio_set(start.field_0x1A4.field_0x0C[1], end.field_0x1A4.field_0x0C[1], ratio); + out.field_0x1A4.field_0x0C[2] = + f32_ratio_set(start.field_0x1A4.field_0x0C[2], end.field_0x1A4.field_0x0C[2], ratio); + + out.field_0x1BC.field_0x00 = u8_ratio_set(start.field_0x1BC.field_0x00, end.field_0x1BC.field_0x00, ratio); + out.field_0x1BC.field_0x04 = f32_ratio_set(start.field_0x1BC.field_0x04, end.field_0x1BC.field_0x04, ratio); + out.field_0x1BC.field_0x08 = f32_ratio_set(start.field_0x1BC.field_0x08, end.field_0x1BC.field_0x08, ratio); + + out.field_0x1BC.field_0x0C = u8_ratio_set(start.field_0x1BC.field_0x0C, end.field_0x1BC.field_0x0C, ratio); + out.field_0x1BC.field_0x10 = f32_ratio_set(start.field_0x1BC.field_0x10, end.field_0x1BC.field_0x10, ratio); + out.field_0x1BC.field_0x14 = f32_ratio_set(start.field_0x1BC.field_0x14, end.field_0x1BC.field_0x14, ratio); + + out.field_0x1BC.field_0x18 = u8_ratio_set(start.field_0x1BC.field_0x18, end.field_0x1BC.field_0x18, ratio); + + out.field_0x1BC.field_0x19 = color_ratio_set( + mColor(*(u32 *)&start.field_0x1BC.field_0x19), mColor(*(u32 *)&end.field_0x1BC.field_0x19), ratio + ); + + out.field_0x1BC.field_0x1D = u8_ratio_set(start.field_0x1BC.field_0x1D, end.field_0x1BC.field_0x1D, ratio); + + out.field_0x1D4.field_0x00 = f32_ratio_set(start.field_0x1D4.field_0x00, end.field_0x1D4.field_0x00, ratio); + out.field_0x1D4.field_0x04 = f32_ratio_set(start.field_0x1D4.field_0x04, end.field_0x1D4.field_0x04, ratio); + out.field_0x1D4.field_0x08 = f32_ratio_set(start.field_0x1D4.field_0x08, end.field_0x1D4.field_0x08, ratio); + out.field_0x1D4.field_0x0C = f32_ratio_set(start.field_0x1D4.field_0x0C, end.field_0x1D4.field_0x0C, ratio); + + out.field_0x1D4.field_0x10 = u8_ratio_set(start.field_0x1D4.field_0x10, end.field_0x1D4.field_0x10, ratio); + out.field_0x1D4.field_0x11 = u8_ratio_set(start.field_0x1D4.field_0x11, end.field_0x1D4.field_0x11, ratio); + + out.field_0x1D4.field_0x12 = u16_ratio_set(start.field_0x1D4.field_0x12, end.field_0x1D4.field_0x12, ratio); + + out.field_0x1D4.field_0x14 = f32_ratio_set(start.field_0x1D4.field_0x14, end.field_0x1D4.field_0x14, ratio); + out.field_0x1D4.field_0x18 = f32_ratio_set(start.field_0x1D4.field_0x18, end.field_0x1D4.field_0x18, ratio); + out.field_0x1D4.field_0x1C = f32_ratio_set(start.field_0x1D4.field_0x1C, end.field_0x1D4.field_0x1C, ratio); + out.field_0x1D4.field_0x20 = f32_ratio_set(start.field_0x1D4.field_0x20, end.field_0x1D4.field_0x20, ratio); + + out.mParticleTransparentClr = color_ratio_set(start.mParticleTransparentClr, end.mParticleTransparentClr, ratio); + out.mParticleSolidClr = color_ratio_set(start.mParticleSolidClr, end.mParticleSolidClr, ratio); +} + +void __Spf_ct_dt_genertation() { + Spf s; +} + +void BlurAndPaletteManager::set_palette_transition(s16 before, s16 after, s32 numFrames) { + mTransitionSpfSetting.mIdxBefore = before; + mTransitionSpfSetting.mIdxAfter = after; + mTransitionSpfSetting.mNumFrames = numFrames; + + if (after == 50) { + if (dScGame_c::currentSpawnInfo.isNight()) { + mTransitionSpfSetting.mIdxAfter = 3; + } else { + mTransitionSpfSetting.mIdxAfter = 5; + } + } else if (after == 51) { + if (ItemflagManager::sInstance->getFlagDirect(ITEM_AMBER_TABLET)) { + if (dScGame_c::currentSpawnInfo.isNight()) { + mTransitionSpfSetting.mIdxAfter = 10; + } else { + mTransitionSpfSetting.mIdxAfter = 9; + } + } else if (ItemflagManager::sInstance->getFlagDirect(ITEM_RUBY_TABLET)) { + if (dScGame_c::currentSpawnInfo.isNight()) { + mTransitionSpfSetting.mIdxAfter = 8; + } else { + mTransitionSpfSetting.mIdxAfter = 7; + } + } else { + mTransitionSpfSetting.mIdxAfter = 6; + } + } +} + +void BlurAndPaletteManager::set_override_spf(s16 start, s16 end, f32 ratio) { + mOverrideSpfSetting.mIdxStart = start; + mOverrideSpfSetting.mIdxEnd = end; + mOverrideSpfSetting.mRatio = ratio; +} + +void BlurAndPaletteManager::setMist(u8 mode, u8 decay, u8 alpha, f32 dir, f32 speed) { + mMistInfo.mMode = mode; + mMistInfo.mDecay = decay; + mMistInfo.mDirection = dir; + mMistInfo.mSpeed = speed; + mMistInfo.mAlpha = alpha; +} + +void BlurAndPaletteManager::setMistMode3(const mVec3_c &pos, f32 value) { + mMistInfo.mMode = 3; + mMistInfo.mDecay = value * 128.f; + mMistPos = pos; + mMistInfo.mSpeed = value * 200.f; + mMistInfo.mAlpha = 0; +} + +void BlurAndPaletteManager::setDOF(f32 dof) { + mDofEnabled = true; + mDof = dof; +} + +void BlurAndPaletteManager::disableDOF() { + mDofEnabled = false; +} + +void BlurAndPaletteManager::light_influence_ratio_set( + LIGHT_INFLUENCE &out, const LIGHT_INFLUENCE &start, const LIGHT_INFLUENCE &end, f32 ratio +) { + mColor black(0, 0, 0, 0); + + out.mIdx = start.mIdx; + out.field_0x18 = start.field_0x18; + + if (ratio <= 0.5f) { + f32 i_ratio = ratio * 2.f; + out.mPos = start.mPos; + out.mClr = color_ratio_set(start.mClr, black, i_ratio); + out.mScale = f32_ratio_set(start.mScale, 0.f, i_ratio); + } else { + f32 i_ratio = (ratio - 0.5f) * 2.f; + out.mPos = end.mPos; + out.mClr = color_ratio_set(black, end.mClr, i_ratio); + out.mScale = f32_ratio_set(0.f, end.mScale, i_ratio); + } +} + +void BlurAndPaletteManager::sff_ratio_set(Sff &out, const Sff &start, const Sff &end, f32 ratio) { + for (int i = 0; i < 3; ++i) { + out.field_0x00[i].field_0x00 = + color_ratio_set(start.field_0x00[i].field_0x00, end.field_0x00[i].field_0x00, ratio); + out.field_0x00[i].field_0x04 = + f32_ratio_set(start.field_0x00[i].field_0x04, end.field_0x00[i].field_0x04, ratio); + out.field_0x00[i].field_0x08 = + f32_ratio_set(start.field_0x00[i].field_0x08, end.field_0x00[i].field_0x08, ratio); + } +} + +void __Sff_ct_dt_genertation() { + Sff s; +} + +void BlurAndPaletteManager::fn_80024740(u8 idx, u8 value) { + if (idx != 0) { + field_0x5D59[idx - 1].mEnabled = true; + field_0x5D59[idx - 1].mValue = value; + } +} + +bool BlurAndPaletteManager::fn_80024770(u8 idx) { + bool ret = false; + if (idx != 0) { + ret = field_0x5D59[idx - 1].mEnabled; + } + return ret; +} +bool BlurAndPaletteManager::fn_800247A0(u8 idx) { + bool ret = false; + if (idx != 0) { + if (field_0x5D59[idx - 1].mValue != 0) { + ret = true; + } + } + return ret; +} + +void BlurAndPaletteManager::setWind(mVec3_c mPos, f32 f) { + mWind.mVel = mPos; + mWind.field_0x0C = f; +} BlurAndPaletteManager::BlurAndPaletteManager() { mColor grey_aaaaaa = mColor(0xaa, 0xaa, 0xaa, 0xff); @@ -293,7 +741,7 @@ BlurAndPaletteManager::BlurAndPaletteManager() { mVec3_c v1(0.0f, 1.0f, 0.0f); mColor white4_ffffff = mColor(0xff, 0xff, 0xff, 0xff); f32 f1 = 2000.0f; - f32 f2 = 10000.0f; + f32 f2 = 100000.0f; mVec3_c v2(0.0f, 0.0f, 0.0f); mVec3_c v3(1.0f, 1.0f, 1.0f); mColor white5_ffffff = mColor(0xff, 0xff, 0xff, 0xff); @@ -305,95 +753,103 @@ BlurAndPaletteManager::BlurAndPaletteManager() { sPInstance = this; - currentSpf.grey_aaaaaa = grey_aaaaaa; - currentSpf.white_ffffff = white_ffffff; - currentSpf.grey_808080 = grey_808080; - currentSpf.cream_ffffc0 = cream_ffffc0; - currentSpf.grey2_aaaaaa = grey_aaaaaa; - currentSpf.white2_ffffff = white_ffffff; - currentSpf.field_0x18 = 0.6f; - currentSpf.pastel_orange_ffb787 = pastel_orange_ffb787; - currentSpf.field_0x24 = 195.0f; - currentSpf.field_0x20 = 0.5f; - currentSpf.black_000000 = black_000000; - currentSpf.black2_000000 = black_000000; - currentSpf.mSub.grey_787878 = grey_787878; - currentSpf.mSub.white3_ffffff.field_0x00 = white2_ffffff; - currentSpf.mSub.field_0x014.field_0x00 = grey_7f7f7f; - currentSpf.mSub.field_0x060.field_0x00 = grey_7f7f7f; - currentSpf.mSub.field_0x0AC.field_0x00 = grey_7f7f7f; - currentSpf.mSub.field_0x0F8.field_0x00 = grey_7f7f7f; - currentSpf.mCloudColor = yellow_ffd86b; - currentSpf.mSkyColor = sea_blue_29424e; - currentSpf.seafoam_green_b9d8b7 = seafoam_green_b9d8b7; - currentSpf.white3_ffffff = white3_ffffff; - currentSpf.field_0x18C = v2; - currentSpf.field_0x198 = v3; - currentSpf.mSub.field_0x000 = 0.0625f; - currentSpf.mSub.field_0x05C = 0.0625f; - currentSpf.mSub.field_0x0A8 = 0.0625f; - currentSpf.mSub.field_0x0F4 = 0.0625f; + currentSpf.mActorPalette.mAmbientClr = grey_aaaaaa; + currentSpf.mActorPalette.mDiffuseClr = white_ffffff; + currentSpf.mActorPalette.mBrightnessClr = grey_808080; + currentSpf.mActorPalette.mSpecularClr = cream_ffffc0; + currentSpf.mActorPalette.mDarkShadowClr = grey_aaaaaa; + currentSpf.mActorPalette.mDarkLightClr = white_ffffff; + currentSpf.mActorPalette.mSpecular = 0.6f; + currentSpf.mActorPalette.field_0x01C = pastel_orange_ffb787; + currentSpf.mActorPalette.field_0x24 = 195.0f; + currentSpf.mActorPalette.mTemperature = 0.5f; + currentSpf.mActorPalette.mShadowClr = black_000000; + currentSpf.mActorPalette.field_0x02C = black_000000; - currentSpf.grey_787878 = grey_787878; - currentSpf.grey2_787878 = grey_787878; - currentSpf.grey3_787878 = grey_787878; - currentSpf.MAO5_kColor3.field_0x00 = white4_ffffff; - currentSpf.MAO5_kColor3.field_0x04 = f1; - currentSpf.MAO5_kColor3.field_0x08 = f2; - currentSpf.mSub.white3_ffffff.field_0x04 = 45.0f; - currentSpf.mSub.white3_ffffff.field_0x08 = 180.0f; + currentSpf.mStagePalette.mShadowClr = grey_787878; + currentSpf.mStagePalette.mLightClr = white2_ffffff; + currentSpf.mStagePalette.field_0x014 = grey_7f7f7f; + currentSpf.mStagePalette.field_0x060 = grey_7f7f7f; + currentSpf.mStagePalette.field_0x0AC = grey_7f7f7f; + currentSpf.mStagePalette.field_0x0F8 = grey_7f7f7f; + + currentSpf.mSkyPalette.mCloudColor = yellow_ffd86b; + currentSpf.mSkyPalette.mSkyColor = sea_blue_29424e; + currentSpf.mSkyPalette.field_0x14 = seafoam_green_b9d8b7; + currentSpf.mSkyPalette.mSkyFilter = white3_ffffff; + currentSpf.mSkyPalette.mSkyCenter = v2; + currentSpf.mSkyPalette.mSkyScale = v3; + + currentSpf.mStagePalette.mBrightness = 0.0625f; + currentSpf.mStagePalette.field_0x05C = 0.0625f; + currentSpf.mStagePalette.field_0x0A8 = 0.0625f; + currentSpf.mStagePalette.field_0x0F4 = 0.0625f; + + currentSpf.mSkyPalette.field_0x00 = grey_787878; + currentSpf.mSkyPalette.field_0x04 = grey_787878; + currentSpf.mSkyPalette.field_0x08 = grey_787878; + + currentSpf.field_0x1A4.field_0x00.field_0x00 = white4_ffffff; + currentSpf.field_0x1A4.field_0x00.field_0x04 = f1; + currentSpf.field_0x1A4.field_0x00.field_0x08 = f2; + + currentSpf.mStagePalette.mSunMoonAngle1 = 45.0f; + currentSpf.mStagePalette.mSunMoonAngle2 = 180.0f; for (int i = 0; i < 5; i++) { - currentSpf.mSub.field_0x020[i] = black_000000; + currentSpf.mStagePalette.field_0x020[i] = black_000000; field_0x2E08[i] = v1; - currentSpf.mSub.field_0x014.field_0x04[i] = 0; - currentSpf.mSub.field_0x034[i] = 0.0f; - currentSpf.mSub.field_0x048[i] = 0.0f; + currentSpf.mStagePalette.field_0x018[i] = 0; + currentSpf.mStagePalette.field_0x034[i] = 0.0f; + currentSpf.mStagePalette.field_0x048[i] = 0.0f; - currentSpf.mSub.field_0x06C[i] = black_000000; + currentSpf.mStagePalette.field_0x06C[i] = black_000000; field_0x2E44[i] = v1; - currentSpf.mSub.field_0x060.field_0x04[i] = 0; - currentSpf.mSub.field_0x080[i] = 0.0f; - currentSpf.mSub.field_0x094[i] = 0.0f; + currentSpf.mStagePalette.field_0x064[i] = 0; + currentSpf.mStagePalette.field_0x080[i] = 0.0f; + currentSpf.mStagePalette.field_0x094[i] = 0.0f; - currentSpf.mSub.field_0x0B8[i] = black_000000; + currentSpf.mStagePalette.field_0x0B8[i] = black_000000; field_0x2E80[i] = v1; - currentSpf.mSub.field_0x0AC.field_0x04[i] = 0; - currentSpf.mSub.field_0x0CC[i] = 0.0f; - currentSpf.mSub.field_0x0E0[i] = 0.0f; + currentSpf.mStagePalette.field_0x0B0[i] = 0; + currentSpf.mStagePalette.field_0x0CC[i] = 0.0f; + currentSpf.mStagePalette.field_0x0E0[i] = 0.0f; - currentSpf.mSub.field_0x104[i] = black_000000; + currentSpf.mStagePalette.field_0x104[i] = black_000000; field_0x2EBC[i] = v1; - currentSpf.mSub.field_0x0F8.field_0x04[i] = 0; - currentSpf.mSub.field_0x118[i] = 0.0f; - currentSpf.mSub.field_0x12C[i] = 0.0f; + currentSpf.mStagePalette.field_0x0FC[i] = 0; + currentSpf.mStagePalette.field_0x118[i] = 0.0f; + currentSpf.mStagePalette.field_0x12C[i] = 0.0f; } - currentSpf.field_0x1B0.x = 0.55f; - currentSpf.field_0x1B0.y = 1.0f; - currentSpf.field_0x1B0.z = 0.0f; - currentSpf.field_0x1BC = 0; - currentSpf.field_0x1C0 = 1.0f; - currentSpf.field_0x1C4 = 0.5f; - currentSpf.field_0x1C8 = 0; - currentSpf.field_0x1CC = 0.5f; - currentSpf.field_0x1D0 = 0.0f; - currentSpf.field_0x1D4 = 0; - currentSpf.field_0x1D5 = pastel_yellow_fffb04; - currentSpf.field_0x1D9 = 1; - currentSpf.field_0x1DC = 3300.0f; - currentSpf.field_0x1E0 = 3300.0f; - currentSpf.field_0x1E4 = 1000.0f; - currentSpf.field_0x1E8 = 500.0f; - currentSpf.field_0x1EC = 0xFF; - currentSpf.field_0x1ED = 1; - currentSpf.field_0x1EE = 0; - currentSpf.field_0x1F0 = 0.0f; - currentSpf.field_0x1F4 = 0.0f; - currentSpf.field_0x1F8 = 6.93359f; - currentSpf.field_0x1FC = 8.0f; - currentSpf.black3_000000 = black_000000; - currentSpf.black4_000000 = black_000000; + currentSpf.field_0x1A4.field_0x0C[0] = 0.55f; + currentSpf.field_0x1A4.field_0x0C[1] = 1.0f; + currentSpf.field_0x1A4.field_0x0C[2] = 0.0f; + + currentSpf.field_0x1BC.field_0x00 = 0; + currentSpf.field_0x1BC.field_0x04 = 1.0f; + currentSpf.field_0x1BC.field_0x08 = 0.5f; + currentSpf.field_0x1BC.field_0x0C = 0; + currentSpf.field_0x1BC.field_0x10 = 0.5f; + currentSpf.field_0x1BC.field_0x14 = 0.0f; + + currentSpf.field_0x1BC.field_0x18 = 0; + currentSpf.field_0x1BC.field_0x19 = pastel_yellow_fffb04; + currentSpf.field_0x1BC.field_0x1D = 1; + + currentSpf.field_0x1D4.field_0x00 = 3300.0f; + currentSpf.field_0x1D4.field_0x04 = 3300.0f; + currentSpf.field_0x1D4.field_0x08 = 1000.0f; + currentSpf.field_0x1D4.field_0x0C = 500.0f; + currentSpf.field_0x1D4.field_0x10 = 0xFF; + currentSpf.field_0x1D4.field_0x11 = 1; + currentSpf.field_0x1D4.field_0x12 = 0; + currentSpf.field_0x1D4.field_0x14 = 0.0f; + currentSpf.field_0x1D4.field_0x18 = 0.0f; + currentSpf.field_0x1D4.field_0x1C = 6.93359f; + currentSpf.field_0x1D4.field_0x20 = 8.0f; + currentSpf.mParticleTransparentClr = black_000000; + currentSpf.mParticleSolidClr = black_000000; for (int i = 0; i < 3; i++) { currentSff.field_0x00[i].field_0x00 = white4_ffffff; @@ -440,3 +896,89 @@ BlurAndPaletteManager::BlurAndPaletteManager() { field_0x5D04.field_0x00 = field_0x5CE4; field_0x5D04.field_0x20 = field_0x5CE4; } + +BlurAndPaletteManager::~BlurAndPaletteManager() { + sPInstance = nullptr; +} + +void ActorLighting::fn_80026500() { + for (ListType::Iterator start = sList.GetBeginIter(); start != sList.GetEndIter(); ++start) { + // Probably stripped + } +} + +// I want to say something else generated this... +ActorLighting::~ActorLighting() {} + +void ActorLighting::reset() { + field_0x0C = -999999.f; + field_0x10 = -999999.f; + field_0x14 = -999999.f; + field_0x18 = -999999.f; + field_0x1C = -999999.f; + field_0x20 = -999999.f; + field_0x24 = -999999.f; + field_0x28 = -999999.f; + field_0x2C = -999999.f; + + field_0x38 = 999999.f; + + mLightSetIdx = -1; + + mLightingCode = 0xF; // TODO(Lighting Code) + field_0x61 = 0; + field_0x62 = 0; + field_0x30 = 0.f; + field_0x34 = 1.f; + field_0x63 = 0; + field_0x64 = 0; + mTev0Color = mColor(0, 0, 0, 0); + mTevK0Color = mColor(0, 0, 0, 0); + + mTev1Color = mColor(0, 0, 0, 0); + mTev2Color = mColor(0, 0, 0, 0); + mTevPrevColor = mColor(0, 0, 0, 0); + + mTevK1Color = mColor(0, 0, 0, 0); + mTevK2Color = mColor(0, 0, 0, 0); + mTevK3Color = mColor(0, 0, 0, 0); + + mUseTev1 = false; + mUseTev2 = false; + mUseTevPrev = false; + mUseTevK1 = false; + mUseTevK2 = false; + mUseTevK3 = false; +} + +const mColor &ActorLighting::getLightTev2Color() { + if (dObjLight_c::GetInstance() == nullptr) { + return mColor(0, 0, 0, 0); + } else { + return dObjLight_c::GetInstance()->GetColor0x68(); + } +} + +const mColor &ActorLighting::getLightTev1Color() { + if (dObjLight_c::GetInstance() == nullptr) { + return mColor(0, 0, 0, 0); + } else { + return dObjLight_c::GetInstance()->GetColor0x6C(); + } +} + +const mColor &ActorLighting::getLightTev0Color() { + if (dObjLight_c::GetInstance() == nullptr) { + return mColor(0, 0, 0, 0); + } else { + return dObjLight_c::GetInstance()->GetColor0x100(); + } +} + +const mColor &ActorLighting::getLightTevKColor() { + if (dObjLight_c::GetInstance() == nullptr) { + return mColor(0, 0, 0, 0); + } else { + return dObjLight_c::GetInstance()->GetColor0x104(); + } +} diff --git a/src/toBeSorted/d_d3d.cpp b/src/toBeSorted/d_d3d.cpp index 8f62c595..335c8761 100644 --- a/src/toBeSorted/d_d3d.cpp +++ b/src/toBeSorted/d_d3d.cpp @@ -232,7 +232,7 @@ void clearList() { // More screen / list stuff... -void unk2(nw4r::g3d::ResMat &mat, nw4r::g3d::ResMatTevColor &clr, LightingInfo *info) { +void unk2(nw4r::g3d::ResMat &mat, nw4r::g3d::ResMatTevColor &clr, ActorLighting *info) { BlurAndPaletteManager &pllt = BlurAndPaletteManager::GetInstance(); const char *name = mat.GetName(); if (name != nullptr && name[0] == 'M' && name[1] == 'A' && name[2] == '0') { diff --git a/src/toBeSorted/d_emitter.cpp b/src/toBeSorted/d_emitter.cpp index f4d133ee..91127f60 100644 --- a/src/toBeSorted/d_emitter.cpp +++ b/src/toBeSorted/d_emitter.cpp @@ -1038,8 +1038,8 @@ void dEmitterBase_c::loadColors( u8 b2 = 0xFF; u8 r, g, b; - mColor c1 = mgr.GetCurrentSph().black3_000000; - mColor c2 = mgr.GetCurrentSph().black4_000000; + const mColor c1 = mgr.GetCurrentSpf().mParticleTransparentClr; + const mColor c2 = mgr.GetCurrentSpf().mParticleSolidClr; u32 flags = emitter->getDynResUserWork(); u32 factor = flags >> 24; @@ -1059,7 +1059,6 @@ void dEmitterBase_c::loadColors( scaleG = 1.0f - (1.0f - (c1.g / 255.0f)) * fFactor; scaleB = 1.0f - (1.0f - (c1.b / 255.0f)) * fFactor; } else { - const mColor &c = mgr.GetCurrentSph().black4_000000; scaleR = 1.0f - (1.0f - (c2.r / 255.0f)) * fFactor; scaleG = 1.0f - (1.0f - (c2.g / 255.0f)) * fFactor; scaleB = 1.0f - (1.0f - (c2.b / 255.0f)) * fFactor; diff --git a/src/toBeSorted/d_scn_callback.cpp b/src/toBeSorted/d_scn_callback.cpp index 3b1cc927..8c270008 100644 --- a/src/toBeSorted/d_scn_callback.cpp +++ b/src/toBeSorted/d_scn_callback.cpp @@ -11,11 +11,12 @@ #include "nw4r/g3d/res/g3d_respltt.h" #include "rvl/GX/GXTypes.h" #include "sized_string.h" +#include "toBeSorted/blur_and_palette_manager.h" #include "toBeSorted/d_d3d.h" #include "toBeSorted/stage_render_stuff.h" void dScnCallback_c::ExecCallback_CALC_MAT(nw4r::g3d::ScnObj::Timing, nw4r::g3d::ScnObj *obj, u32 param, void *pObj) { - const LightingInfo &info = mpActor->mLightingInfo; + const ActorLighting &info = mpActor->mLightingInfo; mColor tev0 = info.mTev0Color; mColor tev1 = info.mTev1Color; mColor tev2 = info.mTev2Color; diff --git a/src/toBeSorted/d_unk_mdl_stuff_2.cpp b/src/toBeSorted/d_unk_mdl_stuff_2.cpp index 25a8d887..50449efa 100644 --- a/src/toBeSorted/d_unk_mdl_stuff_2.cpp +++ b/src/toBeSorted/d_unk_mdl_stuff_2.cpp @@ -69,11 +69,11 @@ void dShpProcBase_c::draw(mVec3_c *pos) { code = dBgS::GetInstance()->GetLightingCode(pos); } if (code != 0) { - GXSetTevColor(GX_TEVREG0, BlurAndPaletteManager::getLightColor1()); - GXSetTevKColor(GX_KCOLOR0, BlurAndPaletteManager::getLightColor2()); + GXSetTevColor(GX_TEVREG0, ActorLighting::getLightTev0Color()); + GXSetTevKColor(GX_KCOLOR0, ActorLighting::getLightTevKColor()); } else { - GXSetTevColor(GX_TEVREG0, mgr.GetCurrentSph().white2_ffffff); - GXSetTevKColor(GX_KCOLOR0, mgr.GetCurrentSph().grey2_aaaaaa); + GXSetTevColor(GX_TEVREG0, mgr.GetCurrentSpf().mActorPalette.mDarkLightClr); + GXSetTevKColor(GX_KCOLOR0, mgr.GetCurrentSpf().mActorPalette.mDarkShadowClr); } } } @@ -93,8 +93,9 @@ void dShpProcBase_c::doEntry(s32 lightSetId) { entry(); } - -bool dShpProc1_c::create(nw4r::g3d::ResMat mat, nw4r::g3d::ResShp shp, s32 count, mHeapAllocator_c *alloc, bool xlu, u32 *pSize) { +bool dShpProc1_c::create( + nw4r::g3d::ResMat mat, nw4r::g3d::ResShp shp, s32 count, mHeapAllocator_c *alloc, bool xlu, u32 *pSize +) { if (!m3d::proc_c::create(alloc, pSize)) { return false; }