From e1aad98a2d5f8f597d95557cbfc100affb0cc64d Mon Sep 17 00:00:00 2001 From: Elijah Thomas <42302100+elijah-thomas774@users.noreply.github.com> Date: Sat, 10 May 2025 17:23:35 -0400 Subject: [PATCH] progress on d_a_obj_ivy_rope (#109) * init * couple more funcs * progress * smol progress * smol progress 2 * Dont get your hopes up, I just had some lingering things :P * fix merge --- .../SOUE01/rels/d_a_obj_ivy_ropeNP/splits.txt | 3 + .../rels/d_a_obj_ivy_ropeNP/symbols.txt | 32 +- include/c/c_lib.h | 1 + include/d/a/d_a_player.h | 2 +- include/d/a/obj/d_a_obj_ivy_rope.h | 236 +++- include/d/col/c/c_cc_d.h | 19 +- include/d/col/cc/d_cc_d.h | 1 - include/d/d_rope_model.h | 26 + include/m/m3d/m_bline.h | 21 +- include/m/m_mtx.h | 14 +- include/toBeSorted/actor_on_rail.h | 9 + src/REL/d/a/obj/d_a_obj_ivy_rope.cpp | 1190 ++++++++++++++++- src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp | 45 +- src/d/a/obj/d_a_obj_arrow.cpp | 1 - src/m/m3d/m_bline.cpp | 13 +- 15 files changed, 1509 insertions(+), 104 deletions(-) create mode 100644 include/d/d_rope_model.h diff --git a/config/SOUE01/rels/d_a_obj_ivy_ropeNP/splits.txt b/config/SOUE01/rels/d_a_obj_ivy_ropeNP/splits.txt index bf371c42..42a99dbf 100644 --- a/config/SOUE01/rels/d_a_obj_ivy_ropeNP/splits.txt +++ b/config/SOUE01/rels/d_a_obj_ivy_ropeNP/splits.txt @@ -17,3 +17,6 @@ REL/global_destructor_chain.c: REL/d/a/obj/d_a_obj_ivy_rope.cpp: .text start:0x000000F0 end:0x0000F2E8 align:16 .ctors start:0x00000000 end:0x00000004 + .rodata start:0x00000000 end:0x00000310 + .data start:0x00000000 end:0x000005D4 + .bss start:0x00000008 end:0x000002A0 diff --git a/config/SOUE01/rels/d_a_obj_ivy_ropeNP/symbols.txt b/config/SOUE01/rels/d_a_obj_ivy_ropeNP/symbols.txt index d456c122..16435456 100644 --- a/config/SOUE01/rels/d_a_obj_ivy_ropeNP/symbols.txt +++ b/config/SOUE01/rels/d_a_obj_ivy_ropeNP/symbols.txt @@ -3,16 +3,16 @@ _epilog = .text:0x00000030; // type:function size:0x2C scope:global _unresolved = .text:0x00000060; // type:function size:0x4 scope:global __register_global_object = .text:0x00000070; // type:function size:0x1C scope:global __destroy_global_chain = .text:0x00000090; // type:function size:0x54 scope:global -fn_256_F0 = .text:0x000000F0; // type:function size:0x40 +__dt__7mVec3_cFv = .text:0x000000F0; // type:function size:0x40 dAcOivyRope_c_classInit__Fv = .text:0x00000130; // type:function size:0x22C -fn_256_360 = .text:0x00000360; // type:function size:0x58 +__dt__15dShadowCircle_cFv = .text:0x00000360; // type:function size:0x58 __dt__26sFState_c<13dAcOivyRope_c>Fv = .text:0x000003C0; // type:function size:0x58 __dt__29sFStateFct_c<13dAcOivyRope_c>Fv = .text:0x00000420; // type:function size:0x6C __dt__82sStateMgr_c<13dAcOivyRope_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000490; // type:function size:0xA0 __dt__52sFStateMgr_c<13dAcOivyRope_c,20sStateMethodUsr_FI_c>Fv = .text:0x00000530; // type:function size:0xA4 -fn_256_5E0 = .text:0x000005E0; // type:function size:0x4 +__ct__7mVec3_cFv = .text:0x000005E0; // type:function size:0x4 scope:weak __dt__13dAcOivyRope_cFv = .text:0x000005F0; // type:function size:0x1F4 -AcOivyRope__initTightRope = .text:0x000007F0; // type:function size:0x54C +initTightRope__13dAcOivyRope_cFv = .text:0x000007F0; // type:function size:0x54C AcOivyRope__handleSubtype1update = .text:0x00000D40; // type:function size:0x37C fn_256_10C0__13dAcOivyRope_cFv = .text:0x000010C0; // type:function size:0xDC fn_256_11A0 = .text:0x000011A0; // type:function size:0x94 @@ -45,7 +45,7 @@ fn_256_4520 = .text:0x00004520; // type:function size:0x238 fn_256_4760 = .text:0x00004760; // type:function size:0x514 fn_256_4C80 = .text:0x00004C80; // type:function size:0x14 fn_256_4CA0 = .text:0x00004CA0; // type:function size:0x298 -fn_256_4F40 = .text:0x00004F40; // type:function size:0x250 +createBase__13dAcOivyRope_cFv = .text:0x00004F40; // type:function size:0x250 fn_256_5190 = .text:0x00005190; // type:function size:0x3FC fn_256_5590 = .text:0x00005590; // type:function size:0x258 fn_256_57F0 = .text:0x000057F0; // type:function size:0x304 @@ -72,7 +72,7 @@ initializeState_TerryRopeWait__13dAcOivyRope_cFv = .text:0x00006640; // type:fun executeState_TerryRopeWait__13dAcOivyRope_cFv = .text:0x000066C0; // type:function size:0x5C finalizeState_TerryRopeWait__13dAcOivyRope_cFv = .text:0x00006720; // type:function size:0x4 createHeap__13dAcOivyRope_cFv = .text:0x00006730; // type:function size:0x478 -AcOivyRope__init = .text:0x00006BB0; // type:function size:0x748 +create__13dAcOivyRope_cFv = .text:0x00006BB0; // type:function size:0x748 fn_256_7300 = .text:0x00007300; // type:function size:0x8 fn_256_7310 = .text:0x00007310; // type:function size:0xB8 fn_256_73D0 = .text:0x000073D0; // type:function size:0x18C @@ -200,15 +200,17 @@ lbl_256_data_2A0 = .data:0x000002A0; // type:object size:0x30 lbl_256_data_2D0 = .data:0x000002D0; // type:object size:0x18 lbl_256_data_2E8 = .data:0x000002E8; // type:object size:0x18 lbl_256_data_300 = .data:0x00000300; // type:object size:0x2A0 -lbl_256_data_5A0 = .data:0x000005A0; // type:object size:0x34 +__vt__28sFStateID_c<13dAcOivyRope_c> = .data:0x000005A0; // type:object size:0x34 __global_destructor_chain = .bss:0x00000000; // type:object size:0x4 scope:global -lbl_256_bss_8 = .bss:0x00000008; // type:object size:0x10 data:4byte -lbl_256_bss_18 = .bss:0x00000018; // type:object size:0x40 data:4byte -lbl_256_bss_58 = .bss:0x00000058; // type:object size:0x40 data:4byte -lbl_256_bss_98 = .bss:0x00000098; // type:object size:0x40 data:4byte -AcOivyRope__STATE_ROPE_CUT = .bss:0x000000D8; // type:object size:0x40 data:4byte -AcOivyRope__STATE_TERRY_ROPE_WAIT = .bss:0x00000118; // type:object size:0xC0 data:4byte -AcOivyRope__STATE_TERRY_ROPE_INIT = .bss:0x000001D8; // type:object size:0x40 data:4byte -AcOivyRope__STATE_TERRY_ROPE_PLAYER_CARRY = .bss:0x00000218; // type:object size:0x70 data:4byte +lbl_256_bss_8 = .bss:0x00000008; // type:object size:0xC data:4byte +StateID_RopeWait__13dAcOivyRope_c = .bss:0x00000018; // type:object size:0x30 data:4byte +StateID_PlayerGrip__13dAcOivyRope_c = .bss:0x00000058; // type:object size:0x30 data:4byte +StateID_RopeReturn__13dAcOivyRope_c = .bss:0x00000098; // type:object size:0x30 data:4byte +StateID_RopeCut__13dAcOivyRope_c = .bss:0x000000D8; // type:object size:0x30 data:4byte +StateID_TerryRopeWait__13dAcOivyRope_c = .bss:0x00000118; // type:object size:0x30 data:4byte +StateID_TerryRopeUp__13dAcOivyRope_c = .bss:0x00000158; // type:object size:0x30 data:4byte +StateID_TerryRopeDown__13dAcOivyRope_c = .bss:0x00000198; // type:object size:0x30 data:4byte +StateID_TerryRopeInit__13dAcOivyRope_c = .bss:0x000001D8; // type:object size:0x30 data:4byte +StateID_TerryRopePlayerCarry__13dAcOivyRope_c = .bss:0x00000218; // type:object size:0x30 data:4byte lbl_256_bss_288 = .bss:0x00000288; // type:object size:0x8 data:byte lbl_256_bss_290 = .bss:0x00000290; // type:object size:0x10 data:float diff --git a/include/c/c_lib.h b/include/c/c_lib.h index 1862235e..ea300953 100644 --- a/include/c/c_lib.h +++ b/include/c/c_lib.h @@ -9,6 +9,7 @@ namespace cLib { s32 targetAngleY(const mVec3_c &target, const mVec3_c &source); s32 targetAngleX(const mVec3_c &target, const mVec3_c &source); f32 addCalcPosXZ(mVec3_c *src, const mVec3_c &target, f32 scale, f32 maxStep, f32 minStep); +f32 addCalcPos(mVec3_c *src, const mVec3_c &target, f32 scale, f32 maxStep, f32 minStep); // made up name f32 easeOut(f32 value, f32 exponent); diff --git a/include/d/a/d_a_player.h b/include/d/a/d_a_player.h index e56ec7f5..ed043bff 100644 --- a/include/d/a/d_a_player.h +++ b/include/d/a/d_a_player.h @@ -98,7 +98,7 @@ public: /* vt 0x0D8 */ virtual void getItemFromClawshotsMaybe(); /* vt 0x0DC */ virtual void vt_0x0DC(dAcBase_c *, mVec3_c &); /* vt 0x0E0 */ virtual void isUsingBomb(); - /* vt 0x0E4 */ virtual void vt_0x0E4(); + /* vt 0x0E4 */ virtual mVec3_c &getCenterTranslation() const; /* vt 0x0E8 */ virtual void vt_0x0E8(); /* vt 0x0EC */ virtual void vt_0x0EC(); /* vt 0x0F0 */ virtual void vt_0x0F0(); diff --git a/include/d/a/obj/d_a_obj_ivy_rope.h b/include/d/a/obj/d_a_obj_ivy_rope.h index f873d816..1f342416 100644 --- a/include/d/a/obj/d_a_obj_ivy_rope.h +++ b/include/d/a/obj/d_a_obj_ivy_rope.h @@ -1,14 +1,34 @@ #ifndef D_A_OBJ_IVY_ROPE_H #define D_A_OBJ_IVY_ROPE_H +#include "common.h" #include "d/a/obj/d_a_obj_base.h" +#include "d/col/c/c_cc_d.h" +#include "d/col/cc/d_cc_d.h" +#include "d/d_rope_model.h" +#include "d/d_shadow.h" +#include "m/m3d/m_smdl.h" +#include "m/m_angle.h" +#include "m/m_vec.h" #include "s/s_State.hpp" -#include "s/s_StateMgr.hpp" +#include "toBeSorted/actor_event.h" +#include "toBeSorted/actor_on_rail.h" +#include "toBeSorted/attention.h" class dAcOivyRope_c : public dAcObjBase_c { public: - dAcOivyRope_c() : mStateMgr(*this, sStateID::null) {} - virtual ~dAcOivyRope_c() {} + dAcOivyRope_c() : mField_0x330(0), mStateMgr(*this, sStateID::null), mStts2(this), mEvent(*this, nullptr) {} + virtual ~dAcOivyRope_c(); + + virtual int create() override; + virtual int doDelete() override; + virtual int draw() override; + virtual bool createHeap() override; + virtual int actorExecute() override; + virtual int actorExecuteInEvent() override; + virtual void registerInEvent() override; + virtual bool canBeLinkedToWoodTag() override; + virtual bool drop() override; STATE_FUNC_DECLARE(dAcOivyRope_c, RopeWait); STATE_FUNC_DECLARE(dAcOivyRope_c, PlayerGrip); @@ -20,8 +40,216 @@ public: STATE_FUNC_DECLARE(dAcOivyRope_c, TerryRopeInit); STATE_FUNC_DECLARE(dAcOivyRope_c, TerryRopePlayerCarry); + void initTightRope(); + void fn_256_10C0(); + + UNKTYPE fn_256_11A0(UNKTYPE); + UNKTYPE fn_256_1240(UNKTYPE); + UNKTYPE fn_256_1480(UNKTYPE); + UNKTYPE fn_256_2160(UNKTYPE); + void fn_256_26B0(int, bool, f32); + UNKTYPE fn_256_2C40(UNKTYPE); + UNKTYPE fn_256_2D00(UNKTYPE); + UNKTYPE fn_256_2DC0(UNKTYPE); + UNKTYPE fn_256_2EA0(UNKTYPE); + void fn_256_30A0(mVec3_c &out); + UNKTYPE fn_256_33B0(UNKTYPE); + UNKTYPE fn_256_34B0(UNKTYPE); + UNKTYPE fn_256_3540(UNKTYPE); + UNKTYPE fn_256_35E0(UNKTYPE); + UNKTYPE fn_256_36A0(UNKTYPE); + UNKTYPE fn_256_3770(UNKTYPE); + UNKTYPE fn_256_3A20(UNKTYPE); + UNKTYPE fn_256_3B90(UNKTYPE); + UNKTYPE calcDistance(UNKTYPE); + UNKTYPE fn_256_3E30(UNKTYPE); + UNKTYPE fn_256_3E70(UNKTYPE); + UNKTYPE fn_256_3F60(UNKTYPE); + UNKTYPE fn_256_43B0(UNKTYPE); + UNKTYPE fn_256_4520(UNKTYPE); + UNKTYPE fn_256_4760(UNKTYPE); + UNKTYPE fn_256_4C80(UNKTYPE); + UNKTYPE fn_256_4CA0(UNKTYPE); + int createBase(); + UNKTYPE fn_256_5190(UNKTYPE); + UNKTYPE fn_256_5590(UNKTYPE); + UNKTYPE fn_256_57F0(UNKTYPE); + UNKTYPE fn_256_5B00(UNKTYPE); + UNKTYPE fn_256_5B64(UNKTYPE); + UNKTYPE fn_256_5B70(UNKTYPE); + UNKTYPE fn_256_5DB0(UNKTYPE); + UNKTYPE fn_256_5FF0(UNKTYPE); + UNKTYPE fn_256_6100(UNKTYPE); + UNKTYPE fn_256_61F0(UNKTYPE); + UNKTYPE fn_256_7300(UNKTYPE); + UNKTYPE fn_256_7310(UNKTYPE); + UNKTYPE fn_256_73D0(UNKTYPE); + UNKTYPE fn_256_7560(UNKTYPE); + UNKTYPE fn_256_7680(UNKTYPE); + UNKTYPE fn_256_7D50(UNKTYPE); + UNKTYPE fn_256_8060(UNKTYPE); + UNKTYPE fn_256_8590(UNKTYPE); + UNKTYPE fn_256_8990(UNKTYPE); + UNKTYPE fn_256_8D10(UNKTYPE); + void fn_256_9120(u16); + UNKTYPE fn_256_9280(UNKTYPE); + UNKTYPE fn_256_9450(UNKTYPE); + UNKTYPE fn_256_9C80(UNKTYPE); + UNKTYPE fn_256_A040(UNKTYPE); + void fn_256_A2C0(bool); + bool fn_256_A750(bool bool0, f32 float0); + f32 fn_256_AA40(); + f32 fn_256_AAB0(f32, f32); + int fn_256_AAF0(f32, f32); + void fn_256_ABA0(); + void fn_256_AC00(); + void fn_256_AE00(); + void fn_256_B2B0(); + void fn_256_BAB0(mVec3_c &out, int idx, s16 xRot, s16 yRot); + void fn_256_BB70(); + void fn_256_BE80(); + void fn_256_BFF0(int, f32, f32); + f32 fn_256_C200(int); + void fn_256_C410(); + bool fn_256_C6F0(); + void fn_256_C740(); + void fn_256_C810(mVec3_c &pOut, int idx); + void fn_256_C960(); + void fn_256_C980(f32, f32); + UNKTYPE fn_256_C9B0(UNKTYPE); + void fn_256_CD40(); + void fn_256_CE20(f32 *, f32 *, f32 *); + void fn_256_CFA0(bool); + void fn_256_D050(); + void fn_256_D110(); + void fn_256_D1B0(); + void fn_256_D2B0(); + void fn_256_D3D0(mVec3_c &pOut1, mVec3_c &pOut2, s16 param2, bool bool0, f32 float0); + const mVec3_c &fn_256_D730(s32 idx); // Get Path Point + void fn_256_D7A0(s32, const mVec3_c &); // Set Path Point + void fn_256_D850(); // Draw Shadow + void fn_256_DAA0(bool, bool, f32, f32); + void fn_256_DE80(); + void fn_256_DEE0(); + u32 fn_256_DF30(); + void fn_256_E3E0(); + bool fn_256_E790(); + + bool checkSubtype(u32 sub) { + return mSubtype == sub; + } + private: - /* 0x??? */ STATE_MGR_DECLARE(dAcOivyRope_c); + /* 0x 330 */ UNKWORD mField_0x330; + /* 0x 334 */ m3d::smdl_c mMdlArr[2]; + /* 0x 36C */ dShadowCircle_c mShadow; + /* 0x 374 */ dCcD_Sph mSph; + /* 0x 4C4 */ dCcD_Cps mCps1; + /* 0x 634 */ dCcD_Cps mCps2; + /* 0x 7A4 */ dCcD_Cps mCpsArr[3]; + /* 0x BF4 */ dCcD_Cyl mCyl; + /* 0x D44 */ STATE_MGR_DECLARE(dAcOivyRope_c); + /* 0x D80 */ dMultiMat_c mRopeMdl; + /* 0x DCC */ dSkinMat_c mCoilMdl; + /* 0x E24 */ dMultiMat_c mRopeMdl2; + /* 0x E70 */ ActorOnRail3 mPath; + /* 0x E88 */ u8 _E88[0xE94 - 0xE88]; + /* 0x E94 */ cCcD_Stts mStts2; + /* 0x ED0 */ ActorEventRelated mEvent; + /* 0x F20 */ mVec3_c mTightropeEnd; + /* 0x F2C */ mVec3_c mTightropeStart; + /* 0x F38 */ mVec3_c mField_0xF38; + /* 0x F44 */ mVec3_c mField_0xF44; + /* 0x F50 */ mVec3_c mField_0xF50; + /* 0x F5C */ u8 _F5C[0xF68 - 0xF5C]; + /* 0x F68 */ mVec3_c mField_0xF68; + /* 0x F74 */ u8 _F74[0xFA4 - 0xF74]; + /* 0x FA4 */ f32 mField_0xFA4; + /* 0x FA8 */ f32 mField_0xFA8; + /* 0x FAC */ f32 mField_0xFAC; + /* 0x FB0 */ f32 mField_0xFB0; + /* 0x FB4 */ f32 mField_0xFB4; + /* 0x FB8 */ f32 mDistance; + /* 0x FBC */ f32 mOldDistance; + /* 0x FC0 */ UNKWORD mField_0xFC0; + /* 0x FC4 */ f32 mField_0xFC4; + /* 0x FC8 */ UNKWORD mField_0xFC8; + /* 0x FCC */ mAng mField_0xFCC; + /* 0x FCE */ u16 mField_0xFCE; + /* 0x FD0 */ u8 _FD0[0xFD2 - 0xFD0]; + /* 0x FD2 */ s16 mField_0xFD2; + /* 0x FD4 */ s16 mField_0xFD4; + /* 0x FD6 */ s16 mField_0xFD6; + /* 0x FD8 */ s16 mField_0xFD8; + /* 0x FDA */ mAng mField_0xFDA; + /* 0x FDC */ s16 mField_0xFDC; + /* 0x FDA */ u8 _FDE[0xFE2 - 0xFDE]; + /* 0x FE2 */ s16 mField_0xFE2; + /* 0x FE4 */ u8 mDropsceneFlag; + /* 0x FE5 */ u8 mWoodTagSceneflag; + /* 0x FE6 */ u8 mSegmentCount; + /* 0x FE7 */ u8 mSubtype; + /* 0x FE8 */ bool mbField_0xFE8; + /* 0x FE9 */ u8 mField_0xFE9; + /* 0x FEA */ u8 mField_0xFEA; + /* 0x FEB */ u8 mField_0xFEB; + /* 0x FEC */ u8 mField_0xFEC; + /* 0x FED */ u8 mEventIdx; + /* 0x FEE */ u8 mField_0xFEE; + /* 0x FEF */ u8 mField_0xFEF; + /* 0x FF0 */ u8 mField_0xFF0[4]; + /* 0x FF4 */ u8 mField_0xFF4; + /* 0x FF5 */ u8 mField_0xFF5; + /* 0x FF6 */ u8 mField_0xFF6; + /* 0x FF7 */ u8 mField_0xFF7; + /* 0x FF8 */ u8 mField_0xFF8; + /* 0x FF9 */ u8 _FF9[0x1005 - 0xFF9]; + /* 0x1005 */ u8 mField_0x1005; + /* 0x1006 */ u8 _1006[0x1010 - 0x1006]; + /* 0x1010 */ mVec3_c mField_0x1010; + /* 0x101C */ mVec3_c mField_0x101C; + /* 0x1028 */ f32 mField_0x1028; + /* 0x102C */ f32 mField_0x102C; + /* 0x1030 */ mAng mField_0x1030; + /* 0x1032 */ mAng mField_0x1032; + /* 0x1034 */ u8 _1034[0x1038 - 0x1034]; + /* 0x1038 */ u8 mField_0x1038; + /* 0x1039 */ u8 mField_0x1039; // TODO make field enum + /* 0x103A */ s8 mField_0x103A; + /* 0x103B */ u8 mField_0x103B; + /* 0x103C */ u8 mField_0x103C; + /* 0x103D */ u8 mField_0x103D; + /* 0x103E */ bool mDropped; + /* 0x1040 */ f32 mField_0x1040; + /* 0x1044 */ u8 _1044[0x1050 - 0x1044]; + /* 0x1050 */ f32 mField_0x1050; + /* 0x1054 */ u8 _1054[0x105E - 0x1054]; + /* 0x105E */ u8 mField_0x105E; + /* 0x105F */ u8 mField_0x105F; + /* 0x1060 */ u8 mField_0x1060; + /* 0x1061 */ u8 mField_0x1061; + /* 0x1062 */ u8 mField_0x1062; + /* 0x1064 */ f32 mField_0x1064; + /* 0x1068 */ f32 mField_0x1068; + /* 0x106C */ f32 mField_0x106C; + /* 0x1070 */ u8 _1070[0x1083 - 0x1070]; + /* 0x1083 */ u8 mField_0x1083; + /* 0x1084 */ u8 _1084[0x1088 - 0x1084]; + /* 0x1088 */ dCcD_Cps mCpsArr2[16]; + /* 0x2788 */ mVec3_c *mPnts1; + /* 0x278C */ mVec3_c *mPnts2; + /* 0x2790 */ u16 mField_0x2790; + /* 0x2792 */ u8 mField_0x2792; + /* 0x2793 */ bool mbField_0x2793; + /* 0x2794 */ u8 _2794[0x27C0 - 0x2794]; + /* 0x27C0 */ f32 mField_0x27C0; + /* 0x27C4 */ bool mbField_0x27C4; + /* 0x27C5 */ bool mbField_0x27C5; + + static InteractionTargetDef sInteraction; + static dCcD_SrcCps sCpsSrc; + static dCcD_SrcSph sSphSrc; + static dCcD_SrcCyl sCylSrc; }; #endif diff --git a/include/d/col/c/c_cc_d.h b/include/d/col/c/c_cc_d.h index 2893419d..1636248d 100644 --- a/include/d/col/c/c_cc_d.h +++ b/include/d/col/c/c_cc_d.h @@ -293,6 +293,9 @@ public: /* 0x38 */ int mRank; cCcD_Stts(dAcObjBase_c *); + ~cCcD_Stts() { + mpActor = nullptr; + } void Move(); int GetID() const; void PlusCcMove(f32, f32, f32); @@ -357,6 +360,8 @@ enum dCcD_ObjAtType { /* 0x 0200 0000 */ AT_TYPE_0x2000000 = (1 << 25), /* 0x 0400 0000 */ AT_TYPE_KOLOKTOS_SWORD = (1 << 26), /* 0x 0800 0000 */ AT_TYPE_0x8000000 = (1 << 27), + /* 0x 0148 8200 */ AT_TYPE_COMMON0 = + AT_TYPE_BUGNET | AT_TYPE_BEETLE | AT_TYPE_0x80000 | AT_TYPE_0x8000 | AT_TYPE_WIND, }; enum cCcD_AtModifiers_e { @@ -790,8 +795,14 @@ public: mCo.OnSPrm(f); } - void SetTgType(u32 flag) { - mTg.SetType(flag); + void SetTgType(u32 type) { + mTg.SetType(type); + } + void OnTgType(u32 type) { + mTg.OnType(type); + } + void OffTgType(u32 type) { + mTg.OffType(type); } void SetAtFlag(u32 flag) { mAt.SetSPrm(flag); @@ -913,6 +924,10 @@ public: return mTg.MskSPrm(0x400); } + void OnTg_0x200000() { + mTg.OnSPrm(0x200000); + } + void SetTg_0x4B(u8 val) { mTg.Set_0x4B(val); } diff --git a/include/d/col/cc/d_cc_d.h b/include/d/col/cc/d_cc_d.h index a99588f9..88dff6b7 100644 --- a/include/d/col/cc/d_cc_d.h +++ b/include/d/col/cc/d_cc_d.h @@ -2,7 +2,6 @@ #define D_CC_D_H #include "d/col/c/c_cc_d.h" -#include "d/col/c/c_m3d.h" #include "m/m_vec.h" struct dCcD_SrcCps { diff --git a/include/d/d_rope_model.h b/include/d/d_rope_model.h new file mode 100644 index 00000000..819663d4 --- /dev/null +++ b/include/d/d_rope_model.h @@ -0,0 +1,26 @@ +#ifndef D_ROPE_MODEL_H +#define D_ROPE_MODEL_H + +#include "m/m3d/m_bline.h" + +// +// The names in this file are made up based on the usage in setupGX +// + +class dMultiMat_c : public m3d::blineMat_c { +public: + dMultiMat_c() {} + virtual void setupGX(bool bTransparent) override; +}; + +class dSkinMat_c : public m3d::blineMat_c { +public: + dSkinMat_c() : mField_0x4C(-1), mField_0x50(0xFF), mField_0x54(0xFF) {} + virtual void setupGX(bool bTransparent) override; + + /* 0x4C */ s32 mField_0x4C; + /* 0x50 */ s32 mField_0x50; + /* 0x54 */ s32 mField_0x54; +}; + +#endif diff --git a/include/m/m3d/m_bline.h b/include/m/m3d/m_bline.h index cb47c32f..7e4a26f2 100644 --- a/include/m/m3d/m_bline.h +++ b/include/m/m3d/m_bline.h @@ -1,9 +1,11 @@ #ifndef M3D_BLINE_H #define M3D_BLINE_H +#include "common.h" #include "egg/gfx/eggTexture.h" #include "m/m3d/m_proc.h" #include "m/m_math.h" +#include "m/m_vec.h" #include "nw4r/ut/ut_Color.h" namespace m3d { @@ -11,26 +13,20 @@ namespace m3d { // The Actual line class bline_c { public: - bline_c() : mpPathArr(0), mpVtxPosArr(0), mpVtxNrmArr(0), mpVtxTexArr(0), mFlags(0) {} + bline_c() : mpPathArr(nullptr), mpVtxPosArr(nullptr), mpVtxNrmArr(nullptr), mpVtxTexArr(nullptr), mFlags(0) {} // This is mainly a Guess, When the array is created, it has both a ctor/dtor struct VtxPos { mVec3_c pos1; mVec3_c pos2; }; struct Vec3u8 { + Vec3u8() {} u8 x, y, z; }; // This is mainly a Guess, When the array is created, it has only a ctor struct VtxNrm { -#pragma warning off(10402) - union { - struct { - Vec3u8 nrm1; - Vec3u8 nrm2; - }; - EGG::Vector3s nrm_u16; // There is a short by short copy later - }; -#pragma warning on(10402) + Vec3u8 nrm1; + Vec3u8 nrm2; }; // This is mainly a Guess, When the array is created, it doesnt use the array alloc struct VtxTex { @@ -44,6 +40,10 @@ public: void remove(); void draw(); + mVec3_c &getPathPoint(u16 idx) { + return mpPathArr[idx]; + } + // vt at 0x08 virtual ~bline_c(); @@ -63,6 +63,7 @@ public: class blineMat_c : public proc_c { public: + blineMat_c() : mpLineArr(nullptr) {} virtual ~blineMat_c(); virtual void remove() override; virtual void drawOpa() override; diff --git a/include/m/m_mtx.h b/include/m/m_mtx.h index 668cfe5f..d353a30d 100644 --- a/include/m/m_mtx.h +++ b/include/m/m_mtx.h @@ -17,7 +17,7 @@ class mMtx_c : public EGG::Matrix34f { typedef const f32 (*MtxRefConst)[4]; public: - mMtx_c(){}; + mMtx_c() {}; mMtx_c(f32 xx, f32 xy, f32 xz, f32 xw, f32 yx, f32 yy, f32 yz, f32 yw, f32 zx, f32 zy, f32 zz, f32 zw); operator MtxRef() { @@ -78,17 +78,27 @@ public: return ret; } + void multVec(const mVec3_c &in, mVec3_c &out) const { + PSMTXMultVec(*this, in, out); + } + mMtx_c &operator+=(const mMtx_c &rhs) { PSMTXConcat(*this, rhs, *this); return *this; } + mVec3_c operator*(const mVec3_c &rhs) { + mVec3_c out; + PSMTXMultVec(*this, rhs, out); + return out; + } + void applyQuat(mQuat_c &quat) { PSMTXMultVec(m, quat.v, quat.v); } void fn_802F1C40(s32, s32); - void makeRotationFromVecs(const mVec3_c&, const mVec3_c&, f32); + void makeRotationFromVecs(const mVec3_c &, const mVec3_c &, f32); public: static mMtx_c Identity; diff --git a/include/toBeSorted/actor_on_rail.h b/include/toBeSorted/actor_on_rail.h index 11a4fd16..b4e1924e 100644 --- a/include/toBeSorted/actor_on_rail.h +++ b/include/toBeSorted/actor_on_rail.h @@ -73,4 +73,13 @@ private: mVec3_c mPosition; }; +class ActorOnRail3 { + ActorOnRail mPath; + u16 mSomePntIdx; + u32 mFlags; + +public: + ActorOnRail3() : mSomePntIdx(0), mFlags(0) {} +}; + #endif diff --git a/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp b/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp index 8018c050..a0ed45dd 100644 --- a/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp +++ b/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp @@ -1,5 +1,32 @@ #include "d/a/obj/d_a_obj_ivy_rope.h" +#include "c/c_lib.h" +#include "c/c_math.h" +#include "common.h" +#include "d/a/d_a_player.h" +#include "d/a/obj/d_a_obj_base.h" +#include "d/col/c/c_cc_d.h" +#include "d/col/c/c_m3d_g_lin.h" +#include "d/col/cc/d_cc_s.h" +#include "d/flag/sceneflag_manager.h" +#include "egg/math/eggMath.h" +#include "m/m3d/m3d.h" +#include "m/m_angle.h" +#include "m/m_mtx.h" +#include "m/m_quat.h" +#include "m/m_vec.h" +#include "nw4r/math/math_arithmetic.h" +#include "nw4r/math/math_triangular.h" +#include "rvl/MTX/mtxvec.h" +#include "s/s_Math.h" +#include "toBeSorted/attention.h" + +// TODO inline? +inline void addAng(mVec3_c &pnt, const f32 step, const mAng &angle) { + pnt.x += step * angle.sin(); + pnt.z += step * angle.cos(); +} + SPECIAL_ACTOR_PROFILE(OBJ_IVY_ROPE, dAcOivyRope_c, fProfile::OBJ_IVY_ROPE, 0x262, 0, 2); STATE_DEFINE(dAcOivyRope_c, RopeWait); @@ -12,30 +39,1151 @@ STATE_DEFINE(dAcOivyRope_c, TerryRopeDown); STATE_DEFINE(dAcOivyRope_c, TerryRopeInit); STATE_DEFINE(dAcOivyRope_c, TerryRopePlayerCarry); -void dAcOivyRope_c::initializeState_RopeWait() {} -void dAcOivyRope_c::executeState_RopeWait() {} -void dAcOivyRope_c::finalizeState_RopeWait() {} -void dAcOivyRope_c::initializeState_PlayerGrip() {} -void dAcOivyRope_c::executeState_PlayerGrip() {} -void dAcOivyRope_c::finalizeState_PlayerGrip() {} -void dAcOivyRope_c::initializeState_RopeReturn() {} -void dAcOivyRope_c::executeState_RopeReturn() {} -void dAcOivyRope_c::finalizeState_RopeReturn() {} -void dAcOivyRope_c::initializeState_RopeCut() {} -void dAcOivyRope_c::executeState_RopeCut() {} -void dAcOivyRope_c::finalizeState_RopeCut() {} -void dAcOivyRope_c::initializeState_TerryRopeWait() {} -void dAcOivyRope_c::executeState_TerryRopeWait() {} -void dAcOivyRope_c::finalizeState_TerryRopeWait() {} -void dAcOivyRope_c::initializeState_TerryRopeUp() {} -void dAcOivyRope_c::executeState_TerryRopeUp() {} -void dAcOivyRope_c::finalizeState_TerryRopeUp() {} -void dAcOivyRope_c::initializeState_TerryRopeDown() {} -void dAcOivyRope_c::executeState_TerryRopeDown() {} -void dAcOivyRope_c::finalizeState_TerryRopeDown() {} +InteractionTargetDef dAcOivyRope_c::sInteraction = { + 0, 0, 1, GRAB, 0, 150.f, 60.f, 0.f, 200.f, 650.f, 50.f, 1.f, +}; + +dCcD_SrcCps dAcOivyRope_c::sCpsSrc = { + /* mObjInf */ + {/* mObjAt */ {0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0}, + /* mObjTg */ + {AT_TYPE_0x800000 | AT_TYPE_BEETLE | AT_TYPE_CLAWSHOT | AT_TYPE_ARROW | AT_TYPE_WHIP | AT_TYPE_SLINGSHOT | + AT_TYPE_BOMB | AT_TYPE_SWORD, + 0x111, + {0, 0x19, 0x407}, + 0, + 0}, + /* mObjCo */ {0x4029}}, + /* mCpsInf */ + {10.f} +}; + +dCcD_SrcSph dAcOivyRope_c::sSphSrc = { + /* mObjInf */ + {/* mObjAt */ {AT_TYPE_DAMAGE, 0x11, {0, 0, 0}, 1, 0, 0, 0, 0, 0}, + /* mObjTg */ + {~AT_TYPE_COMMON0, 0x111, {0, 0, 0x407}, 0, 0}, + /* mObjCo */ {0x29}}, + /* mSphInf */ + {100.f} +}; + +dCcD_SrcCyl dAcOivyRope_c::sCylSrc = { + /* mObjInf */ + {/* mObjAt */ {0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0}, + /* mObjTg */ + {AT_TYPE_BELLOWS, 0x311, {0, 0, 8}, 8, 0}, + /* mObjCo */ {0x109}}, + /* mCylInf */ + {10.f, 750.f} +}; + +dAcOivyRope_c::~dAcOivyRope_c() { + if (mPnts1) { + delete[] mPnts1; + mPnts1 = nullptr; + } + if (mPnts2) { + delete[] mPnts2; + mPnts2 = nullptr; + } +} + +void dAcOivyRope_c::initTightRope() {} + +void dAcOivyRope_c::fn_256_10C0() { + mField_0x106C = 0.f; + + mVec3_c pnt; + fn_256_30A0(pnt); + + // TODO +} + +UNKTYPE dAcOivyRope_c::fn_256_11A0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_1240(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_1480(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_2160(UNKTYPE) {} + +void dAcOivyRope_c::fn_256_26B0(int, bool, f32) {} + +UNKTYPE dAcOivyRope_c::fn_256_2C40(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_2D00(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_2DC0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_2EA0(UNKTYPE) {} + +void dAcOivyRope_c::fn_256_30A0(mVec3_c &out) {} + +UNKTYPE dAcOivyRope_c::fn_256_33B0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_34B0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3540(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_35E0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_36A0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3770(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3A20(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3B90(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::calcDistance(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3E30(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3E70(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_3F60(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_43B0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_4520(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_4760(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_4C80(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_4CA0(UNKTYPE) {} + +int dAcOivyRope_c::createBase() { + rotation.set(0, 0, 0); + f32 temp = 2000.f - 750.f; + mDistance = 2000.f; + mOldDistance = 2000.f; + mSegmentCount = 81; + mDropsceneFlag = params >> 12; + mField_0xFEB = 1; + if (temp < 0.f) { + temp = 0.f; + } + temp /= 750.f; + mField_0x1040 = temp; + if (temp > 1.f) { + mField_0x1040 = 1.f; + } + + CREATE_ALLOCATOR(dAcOivyRope_c); + // TODO +} + +UNKTYPE dAcOivyRope_c::fn_256_5190(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_5590(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_57F0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_5B00(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_5B64(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_5B70(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_5DB0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_5FF0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_6100(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_61F0(UNKTYPE) {} + void dAcOivyRope_c::initializeState_TerryRopeInit() {} void dAcOivyRope_c::executeState_TerryRopeInit() {} void dAcOivyRope_c::finalizeState_TerryRopeInit() {} + +void dAcOivyRope_c::initializeState_TerryRopeDown() {} +void dAcOivyRope_c::executeState_TerryRopeDown() {} +void dAcOivyRope_c::finalizeState_TerryRopeDown() {} + +void dAcOivyRope_c::initializeState_TerryRopeUp() {} +void dAcOivyRope_c::executeState_TerryRopeUp() {} +void dAcOivyRope_c::finalizeState_TerryRopeUp() {} + void dAcOivyRope_c::initializeState_TerryRopePlayerCarry() {} void dAcOivyRope_c::executeState_TerryRopePlayerCarry() {} void dAcOivyRope_c::finalizeState_TerryRopePlayerCarry() {} + +void dAcOivyRope_c::initializeState_TerryRopeWait() {} +void dAcOivyRope_c::executeState_TerryRopeWait() {} +void dAcOivyRope_c::finalizeState_TerryRopeWait() {} + +bool dAcOivyRope_c::createHeap() { + mPnts1 = new mVec3_c[mSegmentCount]; +} + +int dAcOivyRope_c::create() {} + +UNKTYPE dAcOivyRope_c::fn_256_7300(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_7310(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_73D0(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_7560(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_7680(UNKTYPE) {} + +void dAcOivyRope_c::initializeState_RopeWait() {} +void dAcOivyRope_c::executeState_RopeWait() {} +void dAcOivyRope_c::finalizeState_RopeWait() {} + +void dAcOivyRope_c::initializeState_PlayerGrip() {} +void dAcOivyRope_c::executeState_PlayerGrip() {} +void dAcOivyRope_c::finalizeState_PlayerGrip() {} + +void dAcOivyRope_c::initializeState_RopeReturn() {} +void dAcOivyRope_c::executeState_RopeReturn() {} +void dAcOivyRope_c::finalizeState_RopeReturn() {} + +void dAcOivyRope_c::initializeState_RopeCut() {} +void dAcOivyRope_c::executeState_RopeCut() { + if (mField_0xFF8 != 0) { + mStateMgr.changeState(StateID_PlayerGrip); + } else { + if (mField_0xFCE != 0 && --mField_0xFCE == 0) { + position = mTightropeEnd; + } + fn_256_8590(); + fn_256_C740(); + } +} +void dAcOivyRope_c::finalizeState_RopeCut() { + position = mTightropeEnd; + mField_0xFCE = 0; +} + +UNKTYPE dAcOivyRope_c::fn_256_7D50(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_8060(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_8590(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_8990(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_8D10(UNKTYPE) {} + +void dAcOivyRope_c::fn_256_9120(u16) {} + +UNKTYPE dAcOivyRope_c::fn_256_9280(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_9450(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_9C80(UNKTYPE) {} + +UNKTYPE dAcOivyRope_c::fn_256_A040(UNKTYPE) { + // Logically wrong i think + if (mField_0x1062 == 0) { + mVec3_c *pnt2 = mPnts2; + int idx = 1; + if (mSegmentCount > idx) { + f32 f1 = 5.f * mField_0x1040 + 8.f; + f32 f2 = -0.05f * mField_0x1040 + 0.15f; + mVec3_c nextPoint; + mVec3_c vec; + mVec3_c *pnt1 = mPnts1 + 1; + while (idx < mSegmentCount) { + nextPoint = pnt2[1]; + vec = (pnt2[1] - pnt2[0]) + pnt1[0]; + vec.y -= f1; + + vec.normalize(); + + pnt2[1] = pnt2[0] + vec * 25.f; + pnt1[0] *= f2; + pnt1[0] += (pnt2[1] - nextPoint) * 0.5f; + + idx++; + pnt1++; + pnt2++; + } + } + + if (mTightropeEnd.y - mDistance >= pnt2->y) { + mField_0x1062 = 1; + } + } + fn_256_A2C0(false); +} + +void dAcOivyRope_c::fn_256_A2C0(bool bool0) { + mMtx_c m = mWorldMtx; + + f32 fVar13 = 0.f; + + f32 fVar14 = mField_0xFAC * (mSegmentCount * 2.f) / 3.0f; + f32 fVar2 = mField_0xFB0 * (mSegmentCount * 2.f) / 3.0f; + + // TODO +} + +bool dAcOivyRope_c::fn_256_A750(bool bool0, f32 float0) { + // Logically wrong i think + int idx = 1; + mVec3_c *pnt = mPnts2; + if (mSegmentCount >= idx) { + f32 f1 = 8.f + mField_0x1040 * 5.f; + f32 f2 = 0.15f + mField_0x1040 * -0.05f; + for (; idx < mSegmentCount; idx++) { + mVec3_c vec = pnt[idx + 1] - pnt[idx] + mPnts1[idx]; + vec -= f1; + vec.normalize(); + pnt[idx] += vec * 25.f; + mPnts1[idx] *= f2; + mPnts1[idx] += (pnt[idx + 1] - pnt[idx]) * float0; + } + } + + if (!bool0) { + for (int i = 0; i < mSegmentCount; ++i) { + fn_256_D7A0(i, mPnts2[mSegmentCount - 1 - i]); + } + } else { + for (int i = 0; i < mSegmentCount; ++i) { + fn_256_D7A0(i, mPnts2[i]); + } + } + + if (mTightropeEnd.y - mDistance >= pnt->y) { + return true; + } else { + return false; + } +} + +f32 dAcOivyRope_c::fn_256_AA40() { + f32 f = mField_0xFB4 / mSegmentCount * 1.5f; + + f32 ret = f; + if (f < 0.6f) { + ret = 0.6f; + } else if (f > 0.9f) { + ret = 0.9f; + } + return ret; +} + +f32 dAcOivyRope_c::fn_256_AAB0(f32 f1, f32 f2) { + if (cM::isZero(f2)) { + return 1.f; + } + return f1 / f2; +} + +int dAcOivyRope_c::fn_256_AAF0(f32 f1, f32 f2) { + // deal with this later ;-; + f32 f = f1 * f2; + f32 c = -(90.f * f) + 55.f * f * f; + f32 a = 0.8f * (1.f - mField_0x1040); + f32 b = (mField_0xFB4 / mSegmentCount) * c; + return mField_0xFD8 * (1.f - a) * (mField_0xFB4 + b); +} + +void dAcOivyRope_c::fn_256_ABA0() { + mField_0xFDA = 0; + mField_0xFDC = 0; + fn_256_BB70(); + fn_256_D050(); + mStateMgr.changeState(StateID_RopeWait); +} + +void dAcOivyRope_c::fn_256_AC00() { + mStateMgr.executeState(); + if (mStateMgr.isState(StateID_PlayerGrip)) { + fn_256_9450(); + } else if (mStateMgr.isState(StateID_RopeReturn)) { + if (mSubtype == 2) { + fn_256_9C80(); + } else { + fn_256_A040(); + } + } else if (mStateMgr.isState(StateID_RopeCut)) { + fn_256_A040(); + } else if (mSubtype == 6) { + fn_256_DAA0(true, false, 4.0f, 0.13f); + } else if (mSubtype == 7) { + fn_256_DAA0(false, false, 4.0f, 0.13f); + } else { + bool check = checkSubtype(0) || checkSubtype(4) || checkSubtype(3) || checkSubtype(7) || checkSubtype(6); + if (check) { + fn_256_DAA0(false, false, 4.0f, 0.13f); + } else { + fn_256_A2C0(true); + } + } + + fn_256_C410(); + mField_0xFF8 = 0; +} + +void dAcOivyRope_c::fn_256_AE00() { + mField_0xFDA = rotation.x; + mField_0xFDC = rotation.y; + rotation.x = 0; + rotation.y = 0; + int i = 0; + updateMatrix(); + mMtx_c m = mWorldMtx; + if (mSegmentCount > i) { + for (; i < mSegmentCount; ++i) { + m.copyFrom(mWorldMtx); + + mMtx_c m_tmp; + m_tmp.transS(0.f, -25.f * i, 0.f); + m += m_tmp; + + m.getTranslation(mPnts2[i]); + mVec3_c tmp = mPnts2[i]; + mVec3_c tmp2 = tmp - position; + + m.copyFrom(mWorldMtx); + m.YrotM(mField_0xFDC); + m.XrotM(mField_0xFDA); + + mMtx_c m_tmp2; + m_tmp2.transS(tmp2); + m += m_tmp2; + + m.getTranslation(tmp); + fn_256_D7A0(i, tmp); + mPnts1[i].set(0.f, 0.f, 0.f); + } + } + + mStts.SetRank(0); + for (int curr_idx = 0, i = 0; i < mField_0xFEB; curr_idx += 4, ++i) { + int end = mSegmentCount - 1; + + int start_idx = curr_idx; + if (start_idx > end) { + start_idx = end; + } + + int end_idx = curr_idx + 4; + if (end_idx > end) { + end_idx = end; + } + + mCpsArr2[i].Set(sCpsSrc); + mCpsArr2[i].SetStts(mStts); + mCpsArr2[i].cM3dGLin::Set(fn_256_D730(start_idx), fn_256_D730(end_idx)); + mCpsArr2[i].SetR(100.f); + mCpsArr2[i].ClrTgSet(); + } + + mField_0x1083 = 0.6f * mSegmentCount; + mVec3_c v = fn_256_D730(mField_0x1083); + v.y -= nw4r::math::FAbs(80.f / mField_0xFDA.sin()); + + fn_256_26B0(mField_0x1083, false, v.y); + mField_0xFE2 = -1; + fn_256_D050(); + + mStateMgr.changeState(StateID_RopeWait); +} + +void dAcOivyRope_c::fn_256_B2B0() { + // TODO +} + +void dAcOivyRope_c::fn_256_BAB0(mVec3_c &out, int idx, s16 xRot, s16 yRot) { + int pnt2_idx = idx - 1; + if (pnt2_idx < 0) { + pnt2_idx = 0; + } + + mMtx_c m; + m.transS(mPnts2[pnt2_idx]); + m.YrotM(yRot); + m.XrotM(xRot); + m.multVec(mVec3_c(0.f, -25.f, 0.f), out); +} + +void dAcOivyRope_c::fn_256_BB70() { + mField_0xFDA = rotation.x; + mField_0xFDC = rotation.y; + rotation.x = 0; + rotation.y = 0; + updateMatrix(); + + mVec3_c *pnt2; + mVec3_c *pnt1; + mMtx_c m = mWorldMtx; + int i; + for (i = 0, pnt1 = &mPnts1[i], pnt2 = &mPnts2[i]; i < mSegmentCount; ++i, pnt2++, pnt1++) { + m.copyFrom(mWorldMtx); + m.YrotM(mField_0xFDC); + m.XrotM(mField_0xFDA); + + mMtx_c m_tmp; + m_tmp.transS(0.f, -25.f * i, 0.f); + m += m_tmp; + + m.getTranslation(*pnt2); + fn_256_D7A0(i, *pnt2); + pnt1->set(0.f, 0.f, 0.f); + } + + mStts.SetRank(1); + for (int curr_idx = 0, i = 0; i < mField_0xFEB; curr_idx += 4, ++i) { + int end = mSegmentCount - 1; + + int start_idx = curr_idx; + if (start_idx > end) { + start_idx = end; + } + + int end_idx = curr_idx + 4; + if (end_idx > end) { + end_idx = end; + } + + mCpsArr2[i].Set(sCpsSrc); + mCpsArr2[i].SetStts(mStts); + mCpsArr2[i].cM3dGLin::Set(fn_256_D730(start_idx), fn_256_D730(end_idx)); + mCpsArr2[i].SetR(100.f); + mCpsArr2[i].ClrTgSet(); + } + + mField_0xFF6 = 1; +} + +void dAcOivyRope_c::fn_256_BE80() { + f32 step = 0.f; + f32 target = 30.f; + mAng angle = mField_0xFCC - 0x8000; + f32 stepSize = 0.13f * target; + + if (mSegmentCount >= 0) { + for (int i = 1; i < mSegmentCount; i++) { + if (sLib::chase(&step, target, stepSize)) { + target *= -1.f; + } + + mPnts1[i].set(0.f, 0.f, 0.f); + + // inline is required + addAng(mPnts1[i], step, angle); + } + } +} + +void dAcOivyRope_c::fn_256_BFF0(int ang, f32 float0, f32 float1) { + f32 target = float0; + f32 tmp = float0 * (0.1f - mField_0x1040 * 0.03f); + f32 step = 0; + f32 f = ang; + + if (mSegmentCount >= 0) { + for (int i = 1; i < mSegmentCount; i++) { + if (sLib::chase(&step, target, tmp)) { + target = cM::isZero(target) ? float0 : 0.f; + } + mAng angle = f; + + mPnts1[i].set(0.f, 0.f, 0.f); + + // inline is required + addAng(mPnts1[i], step, angle); + // mVec3_c &pnt = mPnts1[i]; + // f32 step1 = step; + // pnt.x += step1 * angle.sin(); + // pnt.z += step1 * angle.cos(); + + mPnts1[i].y = float1; + } + } +} + +f32 dAcOivyRope_c::fn_256_C200(int ang) { + // I dont like this function + + // Some stuff with mField_0xFB4 here + + f32 y = mPnts2[mSegmentCount - 1].y; + f32 x = mPnts2[mSegmentCount - 1].x - mTightropeEnd.x; + f32 z = mPnts2[mSegmentCount - 1].z - mTightropeEnd.z; + + f32 float_30 = 30.f * 1.f; + f32 float_60 = 60.f * 1.f; + f32 flaot_100 = 100.f * 1.f; + + f32 sq = EGG::Math::sqrt(x * x + z * z); + f32 ab = nw4r::math::FAbs(y - mTightropeEnd.y); + f32 tmp0, tmp1, tmp2, tmp3; + f32 ret; + + s16 angle = cM::atan2s(sq, ab); + tmp0 = angle / 9102.f; + if (tmp0 > 0.5f) { + tmp0 = 0.5f; + } + + tmp1 = 1.0f - mField_0x1040; + if (tmp1 < 0.3f) { + tmp1 = 0.3f; + } + + tmp2 = mField_0x1050 / 40.f; + tmp3 = tmp2 * tmp1; + if (tmp3 > 0.5f) { + tmp3 = 0.5f; + } + if (tmp2 > 0.5f) { + tmp2 = 0.5f; + } + tmp1 = tmp0 + tmp3; + if (tmp1 > 1.f) { + tmp1 = 1.f; + } + + fn_256_BFF0(ang, tmp1 * (mField_0x1040 * flaot_100 + float_30), tmp1 * float_60); + + return tmp2; +} + +void dAcOivyRope_c::fn_256_C410() { + fn_256_3E70(); + if (mStateMgr.isState(StateID_RopeReturn)) { + mVec3_c diff = dAcPy_c::GetLink()->position - mTightropeEnd; + if (diff.squareMagXZ() > 90000.f) { + return; + } + } + + if (mStateMgr.isState(StateID_PlayerGrip) || mField_0xFCE != 0) { + return; + } + + int count = mSegmentCount - 9; + f32 f2 = dAcPy_c::GetLink()->position.y - 100.f; + f32 f = 150.f + dAcPy_c::GetLink()->position.y; + if (count < 0) { + count = 0; + } + for (int i = 0; i < mField_0xFEB; i++) { + // TODO + } +} + +bool dAcOivyRope_c::fn_256_C6F0() { + if (mField_0x105F) { + mField_0x105F += mField_0x105E; + if (mField_0x105F >= mSegmentCount - 19) { + mField_0x105F = mSegmentCount - 20; + return true; + } + } + return false; +} + +void dAcOivyRope_c::fn_256_C740() { + const f32 f2 = (1.f - mField_0x1040) * 4.f + 1.1f; + if (mField_0xFA4 <= f2) { + const mVec3_c &pnt = fn_256_D730(mSegmentCount - 1); + const mVec3_c diff = pnt - dAcPy_c::GetLink()->position; + const f32 diffmag = diff.squareMagXZ(); + if (diffmag < 28900.f) { + fn_256_C980(450.f, 200.f); + } + } +} + +void dAcOivyRope_c::fn_256_C810(mVec3_c &pOut, int idx) { + if (idx > 0) { + mVec3_c end = fn_256_D730(idx); + mVec3_c start = fn_256_D730(idx - 1); + cLib::addCalcPos(&end, pOut, 0.65f, 75.f, 1.f); + mVec3_c diff = end - start; + diff.normalize(); + pOut = start + diff * 25.f; + } +} + +void dAcOivyRope_c::fn_256_C960() { + fn_256_C980(150.f, 200.f); +} + +void dAcOivyRope_c::fn_256_C980(f32 f0, f32 f1) { + sInteraction.field_0x24 = mDistance + f1; + sInteraction.field_0x14 = f0; + AttentionManager::GetInstance()->addTarget(*this, sInteraction, 0, nullptr); +} + +UNKTYPE dAcOivyRope_c::fn_256_C9B0(UNKTYPE) {} + +void dAcOivyRope_c::fn_256_CD40() { + position = poscopy3 = poscopy2 = fn_256_D730(mSegmentCount - 1); + + mCps1.Set(sCpsSrc); + mCps1.SetStts(mStts); + mCps1.SetR(15.f); + + mCps1.SetTgInfo_0x1(0xB); + + mVec3_c tmp = position; + tmp.y -= 50.f; + mCps1.cM3dGLin::Set(position, tmp); + + mCps1.OnTg_0x200000(); +} + +void dAcOivyRope_c::fn_256_CE20(f32 *pOut1, f32 *pOut2, f32 *pOut3) { + f32 f2, f3; + f32 f1 = mField_0xFD6; + f2 = mField_0xFAC * mField_0xFAC + mField_0xFB0 * mField_0xFB0; + f3 = nw4r::math::FSqrt(f2); + f32 temp = f3 / f1; + f2 = nw4r::math::FAbs(temp); + if (f2 > 1.f) { + mField_0xFAC = (mField_0xFD6 - 1) * mField_0xFCC.cos(); + mField_0xFB0 = (mField_0xFD6 - 1) * -mField_0xFCC.sin(); + + f2 = 1.f; + } + + *pOut1 = f1; + *pOut2 = f3; + *pOut3 = f2; +} + +void dAcOivyRope_c::fn_256_CFA0(bool bool0) { + if (bool0 && mField_0x1005 != 0) { + mField_0x1005 = 0; + mField_0x105F = mSegmentCount - 24; + + mField_0xFF7 = 1; + mField_0xFF6 = 1; + + mField_0xFC4 = 0.05f; + + mField_0xFD6 = 20; + + mField_0xFA4 = 1.1f + (s8)mField_0x1005 * 0.1f; + mField_0xFA8 = 1.1f + (s8)mField_0x1005 * 0.1f; + + mField_0xFD2 = 0; + mField_0xFD4 = 0; + } +} +void dAcOivyRope_c::fn_256_D050() { + bool check = checkSubtype(0) || checkSubtype(4) || checkSubtype(3) || checkSubtype(7) || checkSubtype(6); + if (check) { + mCyl.Set(sCylSrc); + mCyl.SetStts(mStts); + mCyl.SetH(mDistance); + } +} + +void dAcOivyRope_c::fn_256_D110() { + u32 third = (mSegmentCount - 1) / 3; + mField_0xFF0[0] = 0; + for (int i = 1; i <= 3; i++) { + mField_0xFF0[i] = third * i; + if (mField_0xFF0[i] > (mSegmentCount - 1)) { + mField_0xFF0[i] = (mSegmentCount - 1); + } + } +} + +void dAcOivyRope_c::fn_256_D1B0() { + fn_256_D110(); + for (int i = 0; i < 3; i++) { + mCpsArr[i].Set(sCpsSrc); + mCpsArr[i].SetStts(mStts); + mCpsArr[i].ClrCoSet(); + mCpsArr[i].SetR(15.f); + mCpsArr[i].OffTgType(AT_TYPE_BEETLE | AT_TYPE_SLINGSHOT | AT_TYPE_SWORD); + mCpsArr[i].OnTgType(AT_TYPE_0x40); + mCpsArr[i].cM3dGLin::Set(fn_256_D730(mField_0xFF0[i]), fn_256_D730(mField_0xFF0[i + 1])); + } +} + +void dAcOivyRope_c::fn_256_D2B0() { + if (checkObjectProperty(0x1)) { + return; + } + + if (mSubtype == 3 && mField_0x1039 == 3) { + return; + } + + if (mField_0xFEF != 0) { + mField_0xFEF--; + } + + for (int i = 0; i < 3; i++) { + if (mCpsArr[i].ChkTgHit()) { + mField_0xFEF = 2; + } + + mCpsArr[i].cM3dGLin::Set(fn_256_D730(mField_0xFF0[i]), fn_256_D730(mField_0xFF0[i + 1])); + + dCcS::GetInstance()->Set(&mCpsArr[i]); + } +} + +void dAcOivyRope_c::fn_256_D3D0(mVec3_c &pOut1, mVec3_c &pOut2, s16 param2, bool bool0, f32 float0) { + mVec3_c playerPos = dAcPy_c::GetLink()->position; + mVec3_c playerCenter = dAcPy_c::GetLink()->getCenterTranslation(); + + if (bool0) { + f32 a = (playerCenter.x - playerPos.x); + a *= 0.3f; + + f32 b = (playerCenter.z - playerPos.z); + b *= 0.3f; + + playerCenter.x = playerPos.x + a; + playerCenter.z = playerPos.z + b; + } + + mMtx_c m; + m.transS(playerCenter); + mAng3_c playerRot = dAcPy_c::GetLink()->rotation; + m.ZXYrotM(playerRot.x, playerRot.y, playerRot.z); + + // name 100% guess + mAng swingAngle = (mField_0xFCC - 0x8000) - dAcPy_c::GetLink()->rotation.y; + + f32 something = param2 / 5461.f; + if (something > 1.f) { + something = 1.f; + } + + mVec3_c somevec(0.f, 0.f, 0.f); + somevec.x += something * swingAngle.sin(); + somevec.z += something * swingAngle.cos(); + + mVec3_c somevec2(0.f, -25.f, float0); + PSMTXMultVec(m, somevec, somevec2); + somevec2 += somevec; + if (somevec2.z < float0) { + somevec2.z = float0; + } + + // name 100% guess + mVec3_c swingTarget; + PSMTXMultVec(m, somevec, swingTarget); + + cLib::addCalcPos(&pOut2, swingTarget, 0.3f, 50.f, 1.f); + + if (pOut2.squareDistance(somevec2) > something * something) { + pOut1 = pOut2 - somevec2; + pOut1.normalize(); + pOut2 = somevec2 + pOut1 * something; + } + pOut1 = pOut2 - playerPos; + pOut1.normalize(); +} + +// Get Path Point +const mVec3_c &dAcOivyRope_c::fn_256_D730(s32 idx) { + if (mSubtype == 3) { + return mCoilMdl.getLine(0)->getPathPoint(idx); + } else { + return mRopeMdl.getLine(0)->getPathPoint(idx); + } +} + +// Set Path Point +void dAcOivyRope_c::fn_256_D7A0(s32 idx, const mVec3_c &pnt) { + if (mSubtype == 3) { + mCoilMdl.getLine(0)->getPathPoint(idx) = pnt; + } else { + mRopeMdl.getLine(0)->getPathPoint(idx) = pnt; + } +} + +// Draw Shadow +void dAcOivyRope_c::fn_256_D850() { + bool draw_shadow = false; + switch (subtype) { + case 1: + case 2: break; + case 4: { + if (!mbField_0xFE8) { + draw_shadow = true; + } + } break; + case 6: break; + case 7: { + if (mbField_0x27C5) { + draw_shadow = true; + } + } break; + default: draw_shadow = true; break; + } + + if (draw_shadow) { + static mQuat_c shadow_q = mQuat_c(0.f, 0.f, 0.f, 30.f); + if (mSubtype == 7) { + // This section is just weird + int idk; + f32 f; + f32 val; + val = nw4r::math::FAbs(mField_0xF68.y - mField_0x27C0); + if (!(val > 1000.f)) { + f = 250.f; + idk = f; + if (val > 50.f) { + idk = (1000.f - val) * f * (1 / 950.f); + if (idk < 5.f) { + f = 5.f; + idk = f; + } + } + mMtx_c m; + m.transS(mField_0xF68); + drawShadow(mShadow, nullptr, m, &shadow_q, -1, idk, -1, -1, -1, val); + } + } else { + mMtx_c m; + m.transS(fn_256_D730(mSegmentCount - 1)); + drawShadow(mShadow, nullptr, m, &shadow_q, -1, -1, -1, -1, -1, 175.f); + } + } +} + +extern "C" void *getCamera(int idx); +void dAcOivyRope_c::fn_256_DAA0(bool bool0, bool bool1, f32 float0, f32 float1) { + bool cylHitBellows = false; + if ((bool1 || mField_0xFEF != 0) || (mCyl.ChkTgHit() && mCyl.ChkTgAtHitType(AT_TYPE_BELLOWS))) { + mbField_0x2793 = true; + cylHitBellows = true; + mField_0x2792 = 10; + if (mField_0xFEF && mSubtype != 6) { + float0 = 2.5f; + } + } + + if (mbField_0x2793) { + if (mField_0x2790 != 0) { + mField_0x2790--; + } + + // This block is a mess + else if (cylHitBellows) { + mField_0x2790 = 30; + f32 target = float0 - mField_0x1040 * 1.5f; + f32 chasing = 0.f; + f32 step = target * float1; + int ang = dAcPy_c::GetLink()->rotation.y; + u8 *cam = (u8 *)getCamera(0); + if (cam) { + ang = cLib::targetAngleY(*(mVec3_c *)(cam + 0x6C), mTightropeEnd) + 0x2000; + } + ang += cM::rndInt(0x1555); + int i = 1; + if (mSegmentCount > 1) { + for (; i < mSegmentCount; i++) { + BOOL chased = sLib::chase(&chasing, target, step); + if (chased) { + target *= -1.f; + } + mPnts1[i].set(0.f, 0.f, 0.f); + // Inline? + mVec3_c &v = mPnts1[i]; + f32 step = chasing; + + v.x += step * nw4r::math::SinIdx(ang); + v.z += step * nw4r::math::CosIdx(ang); + }; + } + } + + if (fn_256_A750(bool1, 0.5f)) { + if (!bool0) { + mField_0xFD8 = 1; + f32 target0 = -(mField_0xFD8 * mField_0xFCC.cos()); + f32 target1 = -(mField_0xFD8 * -mField_0xFCC.sin()); + sLib::addCalc(&mField_0xFAC, target0, 0.4f, 2.0f, 0.5f); + sLib::addCalc(&mField_0xFB0, target1, 0.4f, 2.0f, 0.5f); + + mField_0xFD2 = mField_0xFAC; + mField_0xFD4 = mField_0xFB0; + + if (mField_0x2792 != 0) { + mField_0x2792--; + } else { + mbField_0x2793 = false; + } + + } else { + mbField_0x2793 = false; + } + } + + } else { + mField_0x2790 = 0; + if (bool0) { + fn_256_9280(); + } else { + fn_256_A2C0(true); + } + } +} + +void dAcOivyRope_c::fn_256_DE80() { + mField_0x1038 = mSegmentCount - 1; + mField_0x101C = mPnts2[mField_0x1038]; + mField_0x102C = mField_0x1028; + mField_0x1032 = 0x4000; + mField_0x1039 = 2; + mField_0x103D = 1; +} + +void dAcOivyRope_c::fn_256_DEE0() { + mField_0x101C = mPnts2[mField_0x1038]; + mField_0x102C = mField_0x1028; + mField_0x1032 = 0x4000; + mField_0x1039 = 4; + mField_0x103D = 0; +} + +u32 dAcOivyRope_c::fn_256_DF30() {} + +void dAcOivyRope_c::fn_256_E3E0() { + static const u8 l_some_table[] = { + /* [0] */ 1, 10, 2, 0, 2, 40, 2, + /* [7] */ 0, 3, 25, 2, 0, 3, + // has 3 more zeros, probably padding + }; + + if (mStateMgr.isState(StateID_PlayerGrip)) { + mField_0x1030 = 60; + } + + switch (mField_0x1039) { + case 1: { + u32 var = fn_256_DF30(); + if (mStateMgr.isState(StateID_PlayerGrip)) { + fn_256_DEE0(); + } else if (mField_0x103D != 0) { + if (mField_0x103C != 0) { + mField_0x103C--; + } else { + mField_0x103D = 0; + mField_0x103C = l_some_table[++mField_0x103B]; + } + + } else if (var == 0) { + if (mField_0x103C != 0) { + mField_0x103C--; + } else if (mField_0x103B >= 12) { + fn_256_DE80(); + } else { + mField_0x103C = l_some_table[++mField_0x103B]; + mField_0x103D = 1; + } + } + } break; + case 2: { + mField_0x1039 = fn_256_DF30(); + if (mStateMgr.isState(StateID_PlayerGrip)) { + fn_256_DEE0(); + } else { + if (fn_256_E790()) { + mField_0x103A = 0; + mField_0x1030 = 60; + mStateMgr.changeState(StateID_RopeReturn); + fn_256_DEE0(); + } + } + } break; + case 3: { + if (mField_0x103A == -1) { + if (fn_256_E790()) { + if (mEventIdx != 0xFF && !mEvent.isThisActorInEvent()) { + static volatile u32 FLAGS_1 = 0x00000001; + static u32 FLAGS_2 = 0x00100001; + u32 f1 = FLAGS_1; + u32 f2 = FLAGS_2; + Event e(mEventIdx, roomid, f2 & ~f1, 0, 0); + mEvent.scheduleEvent(e, 0); + } + } + } else if (mField_0x103A > 0) { + mField_0x103A--; + } else if (mField_0x103A == 0) { + mField_0x1030 = 60; + mStateMgr.changeState(StateID_RopeReturn); + fn_256_DEE0(); + playSound(0xB76 /* HANGDOWN */); + } + } break; + case 4: { + mField_0x1039 = fn_256_DF30(); + } break; + case 5: { + if (checkObjectProperty(0x1)) { + mField_0x1039 = 2; + } else { + for (int i = 0; i < 0x23; i++) { + mField_0x1039 = fn_256_DF30(); + if (mField_0x1039 != 5) { + break; + } + } + if (mField_0x1039 == 5) { + mField_0x1039 = 2; + } + } + } break; + } + + if (mField_0x1039 != 0) { + mSph.SetC(mField_0x1010); + dCcS::GetInstance()->Set(&mSph); + } +} + +bool dAcOivyRope_c::fn_256_E790() { + bool ret = false; + + if (mDropped) { + mField_0x103A = 0xF; + ret = true; + } + + if (mSph.ChkTgHit()) { + mField_0x103A = 0x1; + ret = true; + } + + if (ret) { + SceneflagManager::sInstance->setFlag(roomid, mWoodTagSceneflag); + } + + return ret; +} + +bool dAcOivyRope_c::canBeLinkedToWoodTag() { + if (mSubtype == 3) { + return !SceneflagManager::sInstance->checkBoolFlag(roomid, mWoodTagSceneflag); + } + return false; +} + +bool dAcOivyRope_c::drop() { + bool dropFlag; + if (mDropsceneFlag < 0xFF && !SceneflagManager::sInstance->checkBoolFlag(roomid, mDropsceneFlag)) { + dropFlag = false; + } else { + dropFlag = true; + } + + if (dropFlag) { + mDropped = true; + return true; + } else { + return false; + } +} diff --git a/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp b/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp index b8b18519..5e07e8f1 100644 --- a/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp +++ b/src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp @@ -16,45 +16,16 @@ STATE_DEFINE(dAcOtoD3StoneFigure_c, Eyes); f32 dAcOtoD3StoneFigure_c::sRadius = 85.0f; f32 dAcOtoD3StoneFigure_c::sHeight = 290.0f; -// clang-format off dCcD_SrcCyl dAcOtoD3StoneFigure_c::sCcSrc = { - { - { - 0, - 0, - { - 0, - 0, - 0 - }, - 0, - 0, - 0, - 0, - 0, - 0 - }, - { - ~(AT_TYPE_BUGNET | AT_TYPE_BEETLE | AT_TYPE_0x80000 | AT_TYPE_0x8000 | AT_TYPE_WIND), - 0x1000111, - { - 0x0, - 0x06, - 0x407 - }, - 0, - 0 - }, - { - 0xE9 - } - }, - { - dAcOtoD3StoneFigure_c::sRadius, - dAcOtoD3StoneFigure_c::sHeight - } + {{0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0}, + {~(AT_TYPE_BUGNET | AT_TYPE_BEETLE | AT_TYPE_0x80000 | AT_TYPE_0x8000 | AT_TYPE_WIND), + 0x1000111, + {0, 0x06, 0x407}, + 0, + 0}, + {0xE9}}, + {dAcOtoD3StoneFigure_c::sRadius, dAcOtoD3StoneFigure_c::sHeight} }; -// clang-format on bool dAcOtoD3StoneFigure_c::createHeap() { const char *modelName = getModelName(); diff --git a/src/d/a/obj/d_a_obj_arrow.cpp b/src/d/a/obj/d_a_obj_arrow.cpp index d600ecb2..42e1965d 100644 --- a/src/d/a/obj/d_a_obj_arrow.cpp +++ b/src/d/a/obj/d_a_obj_arrow.cpp @@ -16,7 +16,6 @@ STATE_DEFINE(dAcArrow_c, Bound); // clang-format off cCcD_SrcGObj dAcArrow_c::sCcSrcInf = { - {AT_TYPE_ARROW, 0x8BB, {0x15,0, 0}, 0, 0, 0, 0, 0, 0}, { ~(AT_TYPE_BUGNET | AT_TYPE_BEETLE | AT_TYPE_0x80000 | AT_TYPE_0x8000 | AT_TYPE_ARROW | AT_TYPE_0x100 | AT_TYPE_WIND | AT_TYPE_SLINGSHOT), diff --git a/src/m/m3d/m_bline.cpp b/src/m/m3d/m_bline.cpp index 793986e8..19f506fd 100644 --- a/src/m/m3d/m_bline.cpp +++ b/src/m/m3d/m_bline.cpp @@ -7,7 +7,6 @@ #include "nw4r/g3d/g3d_light.h" #include "nw4r/g3d/g3d_state.h" - namespace m3d { blineMat_c::~blineMat_c() { @@ -61,7 +60,7 @@ void blineMat_c::update() { getCurrentCamera().GetCameraMtx(&camMtx); PSMTXInverse(camMtx, camMtx); - PSMTXMultVec(camMtx, mVec3_c::zero, vec); + PSMTXMultVec(camMtx, mVec3_c::Zero, vec); for (bline_c *line = (bline_c *)nw4r::ut::List_GetNext(&mLines, 0); line != nullptr; line = (bline_c *)nw4r::ut::List_GetNext(&mLines, line)) { @@ -85,15 +84,9 @@ void blineMat_c::setupGX(bool bTransparent) { 0, &mask_diff_color, &mask_diff_alpha, &mask_spec_color, &mask_spec_alpha, &ambObj ); - nw4r::ut::Color ambColor(0xFF, 0xFF, 0xFF, 0xFF); - nw4r::ut::Color matColor(0xFF, 0xFF, 0xFF, 0xFF); - GXSetChanMatColor(GX_COLOR0, matColor); + GXSetChanMatColor(GX_COLOR0, nw4r::ut::Color(0xFF, 0xFF, 0xFF, 0xFF)); - ambColor.r = ambObj.r; - ambColor.g = ambObj.g; - ambColor.b = ambObj.b; - ambColor.a = ambObj.a; - GXSetChanAmbColor(GX_COLOR0, ambColor); + GXSetChanAmbColor(GX_COLOR0, nw4r::ut::Color(ambObj.r, ambObj.g, ambObj.b, ambObj.a)); GXSetNumChans(1); GXSetChanCtrl(GX_COLOR0, TRUE, GX_SRC_REG, GX_SRC_REG, (GXLightID)mask_diff_color, GX_DF_CLAMP, GX_AF_NONE);