From 2df2da338d38ab07094e3d562f31ca0111ce7b68 Mon Sep 17 00:00:00 2001 From: TakaRikka Date: Sun, 10 Sep 2023 17:47:40 -0700 Subject: [PATCH] set up most of player actor stuff --- include/JAZelAudio/JAIZelBasic.h | 9 + include/SSystem/SComponent/c_cc_d.h | 2 + include/SSystem/SComponent/c_m3d_g_tri.h | 1 + include/d/actor/d_a_player.h | 1225 +++++++++++++++++++++- include/d/d_bg_s_acch.h | 208 ++++ include/d/d_bg_s_chk.h | 16 + include/d/d_bg_s_gnd_chk.h | 61 ++ include/d/d_bg_s_grp_pass_chk.h | 30 + include/d/d_bg_s_lin_chk.h | 83 ++ include/d/d_bg_s_poly_pass_chk.h | 17 + include/d/d_bg_s_roof_chk.h | 29 + include/d/d_bg_s_spl_grp_chk.h | 40 + include/d/d_bg_s_wtr_chk.h | 13 + include/d/d_cc_d.h | 395 +++++++ include/d/d_com_inf_game.h | 2 + include/d/d_drawlist.h | 11 + include/m_Do/m_Do_ext.h | 127 +++ 17 files changed, 2258 insertions(+), 11 deletions(-) create mode 100644 include/JAZelAudio/JAIZelBasic.h create mode 100644 include/d/d_bg_s_acch.h create mode 100644 include/d/d_bg_s_chk.h create mode 100644 include/d/d_bg_s_gnd_chk.h create mode 100644 include/d/d_bg_s_grp_pass_chk.h create mode 100644 include/d/d_bg_s_lin_chk.h create mode 100644 include/d/d_bg_s_poly_pass_chk.h create mode 100644 include/d/d_bg_s_roof_chk.h create mode 100644 include/d/d_bg_s_spl_grp_chk.h create mode 100644 include/d/d_bg_s_wtr_chk.h create mode 100644 include/d/d_cc_d.h diff --git a/include/JAZelAudio/JAIZelBasic.h b/include/JAZelAudio/JAIZelBasic.h new file mode 100644 index 000000000..842b90c45 --- /dev/null +++ b/include/JAZelAudio/JAIZelBasic.h @@ -0,0 +1,9 @@ +#ifndef JAZELAUDIO_JAIZELBASIC_H +#define JAZELAUDIO_JAIZELBASIC_H + +class JAIZelAnime { +public: + /* 0x0 */ u8 field_0x0[0x98]; +}; + +#endif /* JAZELAUDIO_JAIZELBASIC_H */ \ No newline at end of file diff --git a/include/SSystem/SComponent/c_cc_d.h b/include/SSystem/SComponent/c_cc_d.h index d9da0cf5b..864b991c8 100644 --- a/include/SSystem/SComponent/c_cc_d.h +++ b/include/SSystem/SComponent/c_cc_d.h @@ -77,6 +77,8 @@ struct cCcD_SrcTriAttr { class cCcD_TriAttr : public cCcD_ShapeAttr, public cM3dGTri { public: + cCcD_TriAttr() {} + virtual void CalcAabBox(); virtual bool GetNVec(cXyz const&, cXyz*) const; virtual bool CrossAtTg(cCcD_CpsAttr const&, cXyz*) const; diff --git a/include/SSystem/SComponent/c_m3d_g_tri.h b/include/SSystem/SComponent/c_m3d_g_tri.h index 686a172b0..adafbc76f 100644 --- a/include/SSystem/SComponent/c_m3d_g_tri.h +++ b/include/SSystem/SComponent/c_m3d_g_tri.h @@ -20,6 +20,7 @@ public: Vec mB; Vec mC; + cM3dGTri() {} cM3dGTri(const Vec *pA, const Vec *pB, const Vec *pC); bool cross(const cM3dGCyl*, Vec*) const; }; diff --git a/include/d/actor/d_a_player.h b/include/d/actor/d_a_player.h index b4285834f..eb5aa6ab7 100644 --- a/include/d/actor/d_a_player.h +++ b/include/d/actor/d_a_player.h @@ -1,14 +1,50 @@ #ifndef D_D_A_PLAYER_H #define D_D_A_PLAYER_H +#include "JAZelAudio/JAIZelBasic.h" #include "JSystem/J3DGraphAnimator/J3DAnimation.h" #include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h" #include "d/d_attention.h" +#include "d/d_bg_s_acch.h" +#include "d/d_bg_s_lin_chk.h" +#include "d/d_cc_d.h" +#include "d/d_drawlist.h" #include "f_op/f_op_actor_mng.h" #include "m_Do/m_Do_ext.h" class mDoExt_MtxCalcOldFrame; class daPy_matAnm_c; +class daPy_HIO_c; + +class daPy_demo_c { +public: + void setDemoType(u16 pType) { mDemoType = pType; } + int getDemoType() const { return mDemoType; } + void setDemoMode(u32 mode) { mDemoMode = mode; } + u32 getDemoMode() const { return mDemoMode; } + int getParam1() const { return mParam1; } + void setOriginalDemoType() { setDemoType(3); } + void setSpecialDemoType() { setDemoType(5); } + void setSystemDemoType() { setDemoType(2); } + void setStick(f32 stick) { mStick = stick; } + void setMoveAngle(s16 angle) { mDemoMoveAngle = angle; } + s16 getMoveAngle() const { return mDemoMoveAngle; } + f32 getStick() { return mStick; } + int getParam0() const { return mParam0; } + void setParam0(int value) { mParam0 = value; } + void setParam1(int value) { mParam1 = value; } + void setParam2(int value) { mParam2 = value; } + +private: + /* 0x00 */ u16 mDemoType; + /* 0x02 */ s16 mDemoMoveAngle; + /* 0x04 */ s16 mTimer; + /* 0x06 */ s16 mParam2; + /* 0x08 */ int mParam0; + /* 0x0C */ int mParam1; + /* 0x10 */ u32 mDemoMode; + /* 0x14 */ f32 mStick; +}; // Size: 0x18 class daPy_py_c : public fopAc_ac_c { public: @@ -33,22 +69,1178 @@ public: /* 0x2F8 */ f32 field_0x2f8; /* 0x2FC */ u8 field_0x2FC[0x300 - 0x2FC]; /* 0x300 */ f32 field_0x300; + /* 0x304 */ daPy_demo_c mDemo; + /* 0x31C */ void* vtbl; + + void onFrollCrashFlg(u32); + void getGrabActorID() const; + void getBokoFlamePos(cXyz*); + void setPlayerPosAndAngle(cXyz*, s16); + void getSwordTopPos() const; + void checkPlayerFly() const; + void checkPlayerNoDraw(); + void getLeftHandPos() const; + void checkPlayerGuard() const; + void getRopeJumpLand() const; + void checkRopeReadyAnime() const; + void checkRopeForceEnd() const; + void getHeadTopPos() const; + void changePlayer(fopAc_ac_c*); + void objWindHitCheck(dCcD_Cyl*); + void setDoButtonQuake(); + void stopDoButtonQuake(int); + void getTactMusic() const; + void getTactTimerCancel() const; + void getGrabMissActor(); + void checkFrontRoll() const; + void checkBottleSwing() const; + void checkCutCharge() const; + void checkTactWait() const; + void setTactZev(u32, int, char*); + void onDekuSpReturnFlg(u8); + void checkComboCutTurn() const; + void getItemID() const; + void getThrowBoomerangID() const; + void checkGrabBarrel(); + void checkRopeTag(); + void voiceStart(u32); + void setOutPower(f32, s16, int); + void getModelJointMtx(u16); + void getOldSpeedY(); + void setHookshotCarryOffset(u32, cXyz const*); + void setPlayerPosAndAngle(f32*[][][][]); + void setPlayerPosAndAngle(cXyz*, csXyz*); + void setThrowDamage(cXyz*, s16, f32, f32, int); + void changeTextureAnime(u16, u16, int); + void cancelChangeTextureAnime(); + void getRopePos() const; +}; + +class daPy_anmHeap_c { +public: + /* 0x0 */ u16 mIdx; + /* 0x2 */ u16 field_0x2; + /* 0x4 */ u32 field_0x4; + /* 0x8 */ u8* mBuffer; + /* 0xC */ JKRSolidHeap* mAnimeHeap; +}; + +class daPy_sightPacket_c : public dDlst_base_c { +public: + daPy_sightPacket_c() {} + virtual void draw(); + virtual ~daPy_sightPacket_c(); + + void setSight(); + void setSightImage(ResTIMG*); + + bool getDrawFlg() { return mDrawFlag; } + void onDrawFlg() { mDrawFlag = true; } + void offDrawFlg() { mDrawFlag = false; } + void setPos(const cXyz* i_pos) { mPos = *i_pos; } + +private: + /* 0x04 */ bool mDrawFlag; + /* 0x05 */ u8 field_0x5[3]; + /* 0x08 */ cXyz mPos; + /* 0x14 */ Mtx field_0x14; + /* 0x44 */ ResTIMG* mpImg; + /* 0x48 */ u8* mpData; + /* 0x4C */ void* field_0x4c; +}; + +class daPy_actorKeep_c { +public: + daPy_actorKeep_c() { clearData(); } + + void setActor(); + void setData(fopAc_ac_c*); + void clearData(); + + u32 getID() const { return mID; } + void setID(u32 id) { mID = id; } + fopAc_ac_c* getActor() const { return mActor; } + fopAc_ac_c* getActorConst() const { return mActor; } + +private: + /* 0x0 */ u32 mID; + /* 0x4 */ fopAc_ac_c* mActor; +}; // Size: 0x8 + +class daPy_footEffect_c { +public: + /* 0x0 */ u8 field_0x0[0x4C]; +}; + +class daPy_swimTailEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0x28]; +}; + +class daPy_mtxFollowEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0xC]; +}; + +class dPa_smokeEcallBack { +public: + /* 0x0 */ u8 field_0x0[0x20]; +}; + +class dPa_cutTurnEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0x10]; +}; + +class daPy_waterDropEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0x20]; +}; + +class daPy_followEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0x1C]; +}; + +class daPy_dmEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0xC]; +}; + +class daPy_mtxPosFollowEcallBack_c { +public: + /* 0x0 */ u8 field_0x0[0x10]; +}; + +class daPy_swBlur_c : public J3DPacket { +public: + /* 0x010 */ u8 field_0x010[0x014 - 0x010]; + /* 0x014 */ int field_0x014; + /* 0x018 */ int field_0x018; + /* 0x01C */ int mBlurColorType; + /* 0x020 */ f32 field_0x020; + /* 0x024 */ void* mpBlurPos; + /* 0x028 */ cXyz field_0x028; + /* 0x034 */ cXyz field_0x034[60]; + /* 0x304 */ cXyz field_0x304[60]; +}; + +class daPy_footData_c { +public: + /* 0x0 */ u8 field_0x0[0x118]; +}; + +struct MagicArmorAuraEntry { + J3DModel* mpYaura00Model; + f32 field_0x4; +}; + +class daPy_anmIndex_c; + +class dBgW { +public: + enum PushPullLabel {}; }; class daPy_lk_c : public daPy_py_c { public: - /* 0x0304 */ s16 field_0x0304; - /* 0x0306 */ s16 field_0x0306; - /* 0x0308 */ u8 field_0x0308[0x030C - 0x0308]; - /* 0x030C */ int field_0x030c; - /* 0x0310 */ u8 field_0x0310[0x0314 - 0x0310]; - /* 0x0314 */ int mDemoMode; - /* 0x0318 */ u8 field_0x0318[0x031C - 0x0318]; - /* 0x031C */ void* vtbl; + enum HEAP_TYPE {}; + + enum daPy_ANM {}; + + enum daPy_UPPER {}; + + void getBoomerangCatchPos() const; + void getLineTopPos(); + void getHookshotRootPos() const; + void getModelJointMtx(u16); + void seStartOnlyReverb(u32); + void seStartMapInfo(u32); + void seStartSwordCut(u32); + void voiceStart(u32); + void itemButton() const; + void itemTrigger() const; + void getReadyItem(); + void checkGroupItem(int, int); + void checkSetItemTrigger(int, int); + void auraJointCB0(int); + void jointBeforeCB(int, J3DTransformInfo*, Quaternion*); + void jointAfterCB(int, J3DTransformInfo*, Quaternion*); + void jointCB0(int); + void jointCB1(); + void setAnimeHeap(JKRSolidHeap*); + void setItemHeap(); + void setBlurPosResource(u16); + void getItemAnimeResource(u16); + void getAnimeResource(daPy_anmHeap_c*, u16, u32); + void getUnderUpperAnime(daPy_anmIndex_c const*, J3DAnmTransform**, J3DAnmTransform**, int, u32); + void setTextureAnimeResource(J3DAnmTexPattern*, int); + void loadTextureAnimeResource(u32, int); + void checkBossBgm(); + void checkMabaAnimeBtp(int); + void checkNormalFace(); + void setTextureAnime(u16, int); + void setPriTextureAnime(u16, int); + void resetPriTextureAnime(); + void setDemoTextureAnime(u16, u16, int, u16); + void resetDemoTextureAnime(); + void setTextureScrollResource(J3DAnmTextureSRTKey*, int); + void loadTextureScrollResource(u32, int); + void playTextureAnime(); + void checkPlayerGuard() const; + void setOutPower(f32, s16, int); + void checkSightLine(f32, cXyz*); + void setBootsModel(J3DModel**); + void setItemModel(); + void checkUpperReadyAnime() const; + void checkUpperReadyThrowAnime() const; + void checkNoCollisionCorret(); + void setDrawHandModel(); + void entryDLSetLight(J3DModel*, u32); + void updateDLSetLight(J3DModel*, u32); + void hideHatAndBackle(J3DMaterial*); + void drawMirrorLightModel(); + void drawShadow(); + void offBodyEffect(); + void onBodyEffect(); + void draw(); + void setAtnList(); + void setActorPointer(); + void setTalkStatus(); + void setHintActor(); + void setDoStatusBasic(); + void setDoStatus(); + void getDirectionFromAngle(s16); + void getDirectionFromShapeAngle(); + void getDirectionFromCurrentAngle(); + void setNormalSpeedF(f32, f32, f32, f32); + void posMoveFromFootPos(); + void posMove(); + void setShapeAngleToAtnActor(); + void cancelItemUpperReadyAnime(); + void checkBodyAngleX(s16); + void setBodyAngleToCamera(); + void setBodyAngleXReadyAnime(); + void setSpeedAndAngleNormal(s16); + void setSpeedAndAngleAtn(); + void setSpeedAndAngleAtnBack(); + void setSpeedAndAngleAtnActor(); + void setFrameCtrl(J3DFrameCtrl*, u8, s16, s16, f32, f32); + void checkAtnWaitAnime(); + void setBlendMoveAnime(f32); + void setBlendAtnBackMoveAnime(f32); + void setBlendAtnMoveAnime(f32); + void setAnimeEquipSword(int); + void setAnimeEquipSingleItem(u16); + void setAnimeEquipItem(); + void setAnimeUnequipSword(); + void setAnimeUnequipItem(u16); + void setAnimeUnequip(); + void checkBossGomaStage(); + void checkSingleItemEquipAnime() const; + void checkItemEquipAnime() const; + void checkEquipAnime() const; + void deleteEquipItem(int); + void setFallVoice(); + void keepItemData(); + void returnKeepItemData(); + void makeItemType(); + void setScopeModel(); + void setPhotoBoxModel(); + void changeDragonShield(int); + void checkNewItemChange(u8); + void checkItemChangeFromButton(); + void checkItemAction(); + void getSlidePolygon(); + void checkJumpCutFromButton(); + void orderTalk(); + void checkNextActionFromButton(); + void setShieldGuard(); + void checkItemModeActorPointer(); + void checkNextActionItemFly(); + void checkNextMode(int); + void checkIceSlipFall(); + void setFrontWallType(); + void changeFrontWallTypeProc(); + void changeSlideProc(); + void changeWaitProc(); + void changeLandProc(f32); + void setDamagePoint(f32); + void checkNormalDamage(int); + void setDashDamage(); + void checkAtHitEnemy(dCcD_GObjInf*); + void checkElecReturnDamage(dCcD_GObjInf*, cXyz*); + void checkWallAtributeDamage(dBgS_AcchCir*); + void changeDamageProc(); + void changeAutoJumpProc(); + void changeDemoProc(); + void changeDeadProc(); + void getDamageVec(dCcD_GObjInf*); + void setOldRootQuaternion(s16, s16, s16); + void checkRestHPAnime(); + void checkHeavyStateOn(); + void checkBottleItem(int) const; + void checkDrinkBottleItem(int) const; + void checkOpenBottleItem(int) const; + void checkBowItem(int) const; + void checkPhotoBoxItem(int) const; + void checkScopeEnd(); + void setSubjectMode(); + void checkMaskDraw(); + void checkSubjectEnd(int); + void checkGuardAccept(); + void cancelNoDamageMode(); + void commonProcInit(); + void procScope_init(int); + void procScope(); + void procSubjectivity_init(int); + void procSubjectivity(); + void procCall_init(); + void procCall(); + void procControllWait_init(); + void procControllWait(); + void procWait_init(); + void procWait(); + void procFreeWait_init(); + void procFreeWait(); + void procMove_init(); + void procMove(); + void procAtnMove_init(); + void procAtnMove(); + void procAtnActorWait_init(); + void procAtnActorWait(); + void procAtnActorMove_init(); + void procAtnActorMove(); + void procSideStep_init(int); + void procSideStep(); + void procSideStepLand_init(); + void procSideStepLand(); + void procCrouchDefense_init(); + void procCrouchDefense(); + void procCrouchDefenseSlip_init(); + void procCrouchDefenseSlip(); + void procCrouch_init(); + void procCrouch(); + void procWaitTurn_init(); + void procWaitTurn(); + void procMoveTurn_init(int); + void procMoveTurn(); + void procSlip_init(); + void procSlip(); + void procSlideFront_init(s16); + void procSlideFront(); + void procSlideBack_init(s16); + void procSlideBack(); + void procSlideFrontLand_init(); + void procSlideFrontLand(); + void procSlideBackLand_init(); + void procSlideBackLand(); + void procFrontRoll_init(f32); + void procFrontRoll(); + void procFrontRollCrash_init(); + void procFrontRollCrash(); + void procNockBackEnd_init(); + void procNockBackEnd(); + void procSideRoll_init(); + void procSideRoll(); + void procBackJump_init(); + void procBackJump(); + void procBackJumpLand_init(); + void procBackJumpLand(); + void checkAutoJumpFlying() const; + void procAutoJump_init(); + void procAutoJump(); + void procLand_init(f32, int); + void procLand(); + void procLandDamage_init(int); + void procLandDamage(); + void procFall_init(int, f32); + void procFall(); + void procSlowFall_init(); + void procSlowFall(); + void procSmallJump_init(int); + void procSmallJump(); + void procVerticalJump_init(); + void procVerticalJump(); + void procGuardCrash(); + void procDamage_init(); + void procDamage(); + void procPolyDamage_init(); + void procPolyDamage(); + void procLargeDamage_init(int, int, s16, s16); + void procLargeDamage(); + void procLargeDamageUp_init(int, int, s16, s16); + void procLargeDamageUp(); + void procLargeDamageWall_init(int, int, s16, s16); + void procLargeDamageWall(); + void procLavaDamage_init(); + void procLavaDamage(); + void procElecDamage_init(cXyz const*); + void procElecDamage(); + void procGuardSlip_init(); + void procGuardSlip(); + void procIceSlipFall_init(); + void procIceSlipFall(); + void procIceSlipFallUp_init(int, s16, s16); + void procIceSlipFallUp(); + void procIceSlipAlmostFall_init(); + void procIceSlipAlmostFall(); + void procBootsEquip_init(u16); + void procBootsEquip(); + void procNotUse_init(int); + void procNotUse(); + void getGroundAngle(cBgS_PolyInfo*, s16); + void setLegAngle(f32, int, s16*, s16*); + void footBgCheck(); + void setWaterY(); + void autoGroundHit(); + void checkAttentionPosAngle(fopAc_ac_c*, cXyz**); + void setNeckAngle(); + void checkOriginalHatAnimation(); + void setHatAngle(); + void setMoveSlantAngle(); + void setWaistAngle(); + void setWorldMatrix(); + void setAtParam(u32, int, dCcG_At_Spl, u8, u8, u8, f32); + void resetCurse(); + void checkLightHit(); + void setSwordAtCollision(); + void getBlurTopRate(); + void setCollision(); + void setAttentionPos(); + void setRoomInfo(); + void setDemoData(); + void setStickData(); + void setBgCheckParam(); + void setParamData(int, int, int, int); + void checkLavaFace(cXyz*, int); + void checkFallCode(); + void startRestartRoom(u32, int, f32, int); + void checkSuccessGuard(int); + void setShapeAngleOnGround(); + void setStepsOffset(); + void setBeltConveyerPower(); + void setWindAtPower(); + void checkRoofRestart(); + void execute(); + void playerDelete(); + void initTextureAnime(); + void initTextureScroll(); + void createHeap(); + void createAnimeHeap(JKRSolidHeap**, daPy_lk_c::HEAP_TYPE); + void initModel(J3DModel**, int, u32); + void entryBtk(J3DModelData*, int); + void entryBrk(J3DModelData*, int); + void playerInit(); + daPy_lk_c(); + void makeBgWait(); + void setSeAnime(daPy_anmHeap_c const*, J3DFrameCtrl*); + void initSeAnime(); + void resetSeAnime(); + void setMoveAnime(f32, f32, f32, daPy_lk_c::daPy_ANM, daPy_lk_c::daPy_ANM, int, f32); + void setSingleMoveAnime(); + void setActAnimeUpper(u16, daPy_lk_c::daPy_UPPER, f32, f32, s16, f32); + void resetActAnimeUpper(); + void animeUpdate(); + void simpleAnmPlay(J3DAnmBase*); + void setHandModel(); + void getAnmData(); + void checkGrabWeapon(int); + void onDekuSpReturnFlg(u8); + void changeTextureAnime(u16, u16, int); + void setThrowDamage(cXyz*, s16, f32, f32, int); + void setPlayerPosAndAngle(cXyz*, s16); + void setPlayerPosAndAngle(cXyz*, csXyz*); + void setPlayerPosAndAngle(f32*[][][][]); + void endDemoMode(); + void getBokoFlamePos(cXyz*); + void setAuraEffect(); + void setWaterRipple(); + void setFootEffectType(int, cXyz*, int, int); + void setFootMark(cXyz*); + void setFootEffect(); + void resetFootEffect(); + void setSwimTail(); + void setCutWaterSplash(); + void setSwimWaterDrop(daPy_waterDropEcallBack_c*); + void setWaterDrop(); + void setDamageFlameEmitter(); + void setDamageCurseEmitter(); + void setDamageElecEmitter(); + void setDamageEmitter(); + void endFlameDamageEmitter(); + void endDamageEmitter(); + void setItemWaterEffect(fopAc_ac_c*, int, int); + void getDemoLookActor(); + void setTinkleCeiverModel(); + void setTalismanModel(); + void setLetterModel(); + void checkCaughtShapeHide(); + void setShapeAngleToTalkActor(); + void checkEndMessage(u32); + void setTalkStartBack(); + void dProcTool_init(); + void dProcTool(); + void dProcTalk_init(); + void dProcTalk(); + void dProcDamage_init(); + void dProcDamage(); + void dProcHoldup_init(); + void dProcHoldup(); + void dProcOpenTreasure_init(); + void dProcOpenTreasure(); + void setGetItemSound(u16, int); + void setGetDemo(); + void dProcGetItem_init(); + void dProcGetItem(); + void dProcUnequip_init(); + void dProcUnequip(); + void dProcLavaDamage_init_sub(); + void dProcLavaDamage_init(); + void dProcLavaDamage(); + void dProcFreezeDamage_init_sub(int); + void dProcFreezeDamage_init(); + void dProcFreezeDamage(); + void dProcDead_init_sub(); + void dProcDead_init_sub2(); + void checkGameOverStart(); + void dProcDead_init(); + void dProcDead(); + void dProcLookAround_init(); + void dProcLookAround(); + void dProcSalute_init(); + void dProcSalute(); + void dProcLookAround2_init(); + void dProcLookAround2(); + void dProcTalismanPickup_init(); + void dProcTalismanPickup(); + void dProcTalismanWait_init(); + void dProcTalismanWait(); + void dProcSurprised_init(); + void dProcSurprised(); + void dProcTurnBack_init(); + void dProcTurnBack(); + void dProcLookUp_init(); + void dProcLookUp(); + void dProcQuakeWait_init(); + void dProcQuakeWait(); + void dProcDance_init(); + void dProcDance(); + void dProcCaught_init(); + void dProcCaught(); + void dProcLookWait_init(); + void dProcLookWait(); + void dProcPushPullWait_init(); + void dProcPushPullWait(); + void dProcPushMove_init(); + void dProcPushMove(); + void dProcDoorOpen_init(); + void dProcDoorOpen(); + void dProcNod_init(); + void dProcNod(); + void dProcPresent_init_sub(); + void dProcPresent_init(); + void dProcPresent(); + void dProcWindChange_init(); + void dProcWindChange(); + void dProcStandItemPut_init(); + void dProcStandItemPut(); + void dProcVorcanoFail_init(); + void dProcVorcanoFail(); + void dProcSlightSurprised_init(); + void dProcSlightSurprised(); + void dProcSmile_init(); + void dProcSmile(); + void dProcBossWarp_init(); + void dProcBossWarp(); + void dProcAgbUse_init(); + void dProcAgbUse(); + void dProcLookTurn_init(); + void dProcLookTurn(); + void dProcLetterOpen_init(); + void dProcLetterOpen(); + void dProcLetterRead_init(); + void dProcLetterRead(); + void dProcRedeadStop_init(); + void dProcRedeadStop(); + void dProcRedeadCatch_init(); + void dProcRedeadCatch(); + void dProcGetDance_init(); + void dProcGetDance(); + void dProcBottleOpenFairy_init(); + void dProcBottleOpenFairy(); + void dProcWarpShort_init(); + void dProcWarpShort(); + void dProcOpenSalvageTreasure_init(); + void dProcOpenSalvageTreasure(); + void dProcSurprisedWait_init(); + void dProcSurprisedWait(); + void dProcPowerUpWait_init(); + void dProcPowerUp_init(); + void dProcPowerUp(); + void dProcShipSit_init(); + void dProcShipSit(); + void dProcLastCombo_init(); + void dProcLastCombo(); + void dProcHandUp_init(); + void dProcHandUp(); + void dProcIceSlip_init(); + void dProcIceSlip(); + void getLadderMoveAnmSpeed(); + void setLadderFootSe(); + void changeLadderMoveProc(int); + void setMoveBGLadderCorrect(); + void procLadderUpStart_init_sub(); + void procLadderUpStart_init(); + void procLadderUpStart(); + void procLadderUpEnd_init(int); + void procLadderUpEnd(); + void procLadderDownStart_init_sub(); + void procLadderDownStart_init(); + void procLadderDownStart(); + void procLadderDownEnd_init(int); + void procLadderDownEnd(); + void procLadderMove_init(int, int, cXyz*); + void procLadderMove(); + void getHangMoveAnmSpeed(); + void getHangDirectionFromAngle(); + void changeHangMoveProc(int); + void changeHangEndProc(int); + void setHangShapeOffset(); + void procHangStart_init(); + void procHangStart(); + void procHangFallStart_init(cM3dGPla*); + void procHangFallStart(); + void procHangUp_init(int); + void procHangUp(); + void procHangWait_init(); + void procHangWait(); + void procHangMove_init(int); + void procHangMove(); + void procHangClimb_init(f32); + void procHangClimb(); + void procHangWallCatch_init(); + void procHangWallCatch(); + void getClimbMoveAnmSpeed(); + void setClimbShapeOffset(); + void getClimbDirectionFromAngle(); + void changeClimbMoveProc(int); + void setMoveBGCorrectClimb(); + void checkBgCorrectClimbMove(cXyz*, cXyz*); + void checkBgClimbMove(); + void procClimbUpStart_init_sub(); + void procClimbUpStart_init(); + void procClimbUpStart(); + void procClimbDownStart_init(s16); + void procClimbDownStart(); + void procClimbMoveUpDown_init(int); + void procClimbMoveUpDown(); + void procClimbMoveSide_init(int); + void procClimbMoveSide(); + void setBlendWHideMoveAnime(f32); + void getWHideModePolygon(cXyz*, cXyz*, cXyz*, int); + void getWHideBasePos(cXyz*); + void getWHideNextPos(cXyz*, cXyz*); + void checkWHideBackWall(cXyz*); + void checkWHideFrontFloor(cXyz*); + void checkWHideModeChange(cXyz*); + void changeWHideEndProc(cXyz*); + void procWHideReady_init(cM3dGPla*, cXyz*); + void procWHideReady(); + void procWHideWait_init(); + void procWHideWait(); + void procWHideMove_init(); + void procWHideMove(); + void procWHidePeep_init(); + void procWHidePeep(); + void getCrawlMoveAnmSpeed(); + void getCrawlMoveSpeed(); + void setCrawlMoveDirectionArrow(); + void changeCrawlAutoMoveProc(cXyz*); + void getCrawlMoveVec(cXyz*, cXyz*, cXyz*); + void crawlBgCheck(cXyz*, cXyz*); + void checkCrawlSideWall(cXyz*, cXyz*, cXyz*, cXyz*, s16*, s16*); + void setDoStatusCrawl(); + void procCrawlStart_init(); + void procCrawlStart(); + void checkNotCrawlStand(cXyz*); + void checkNotCrawlStand(cXyz*, cXyz*); + void procCrawlMove_init(s16, s16); + void procCrawlMove(); + void procCrawlAutoMove_init(int, cXyz*); + void procCrawlAutoMove(); + void procCrawlEnd_init(int, s16, s16); + void procCrawlEnd(); + void checkGrabSpecialHeavyState(); + void getGrabMissActor(); + void setWeaponBlur(); + void checkGrabBarrelSearch(int); + void setGrabItemPos(); + void freeGrabItem(); + void checkNextActionGrab(); + void initGrabNextMode(); + void procGrabReady_init(); + void procGrabReady(); + void procGrabUp_init(); + void procGrabUp(); + void procGrabMiss_init(); + void procGrabMiss(); + void procGrabThrow_init(int); + void procGrabThrow(); + void procGrabPut_init(); + void procGrabPut(); + void procGrabWait_init(); + void procGrabWait(); + void procGrabHeavyWait_init(); + void procGrabHeavyWait(); + void procGrabRebound_init(); + void procGrabRebound(); + void setSpeedAndAngleSwim(); + void checkNextModeSwim(); + void changeSwimProc(); + void changeSwimUpProc(); + void swimOutAfter(int); + void checkSwimFallCheck(); + void changeSwimOutProc(); + void setSwimMoveAnime(); + void getSwimTimerRate(); + void setSwimTimerStartStop(); + void procSwimUp_init(int); + void procSwimUp(); + void procSwimWait_init(int); + void procSwimWait(); + void procSwimMove_init(int); + void procSwimMove(); + void setSpecialBattle(int); + void changeSpecialBattle(); + void procBtJump_init(fopEn_enemy_c*); + void procBtJump(); + void procBtJumpCut_init(cXyz*); + void procBtJumpCut(); + void procBtSlide(); + void procBtRoll_init(fopEn_enemy_c*); + void procBtRoll(); + void procBtRollCut_init(cXyz*); + void procBtRollCut(); + void procBtVerticalJump_init(fopEn_enemy_c*); + void procBtVerticalJump(); + void procBtVerticalJumpCut_init(); + void procBtVerticalJumpCut(); + void procBtVerticalJumpLand_init(); + void procBtVerticalJumpLand(); + void shipSpecialDemoStart(); + void checkJumpRideShip(); + void checkShipNotNormalMode(); + void setShipRideArmAngle(int, J3DTransformInfo*); + void checkShipRideUseItem(int); + void initShipRideUseItem(int, int); + void setShipRidePosUseItem(); + void setShipRidePos(int); + void setShipAttentionAnmSpeed(f32); + void setShipAttnetionBodyAngle(); + void changeShipEndProc(); + void initShipBaseAnime(); + void initShipCraneAnime(); + void procShipReady_init(); + void procShipReady(); + void procShipJumpRide_init(); + void procShipJumpRide(); + void procShipSteer_init(); + void procShipSteer(); + void procShipPaddle_init(); + void procShipPaddle(); + void procShipScope_init(int); + void procShipScope(); + void procShipBoomerang_init(); + void procShipBoomerang(); + void procShipHookshot_init(); + void procShipHookshot(); + void procShipBow_init(); + void procShipBow(); + void procShipCannon_init(); + void procShipCannon(); + void procShipCrane_init(); + void procShipCrane(); + void procShipGetOff_init(); + void procShipGetOff(); + void procShipRestart_init(); + void procShipRestart(); + void checkRopeAnime() const; + void freeRopeItem(); + void checkRopeRoofHit(s16); + void changeRopeSwingProc(); + void changeRopeEndProc(int); + void checkSpecialRope(); + void changeRopeToHangProc(); + void checkRopeSwingWall(cXyz*, cXyz*, s16*, f32*); + void setBlendRopeMoveAnime(int); + void throwRope(); + void checkNextActionRopeReady(); + void checkNextRopeMode(); + void checkHangRopeActorNull(); + void procRopeSubject_init(); + void procRopeSubject(); + void procRopeReady_init(); + void procRopeReady(); + void procRopeSwing_init(fopAc_ac_c*, s16); + void procRopeSwing(); + void procRopeHangWait_init(int); + void procRopeHangWait(); + void specialRopeHangUp(); + void procRopeUp_init(); + void procRopeUp(); + void procRopeDown_init(); + void procRopeDown(); + void procRopeSwingStart_init(); + void procRopeSwingStart(); + void procRopeMove_init(); + void procRopeMove(); + void procRopeThrowCatch_init(); + void procRopeThrowCatch(); + void procRopeUpHang_init(); + void procRopeUpHang(); + void checkRopeReadyAnime() const; + void checkRopeTag(); + void checkPlayerNoDraw(); + void getGroundY(); + void getLeftHandMatrix(); + void getRightHandMatrix(); + void checkPlayerFly() const; + void checkFrontRoll() const; + void checkBottleSwing() const; + void checkCutCharge() const; + void checkTactWait() const; + void getBaseAnimeFrameRate(); + void getBaseAnimeFrame(); + void getItemID() const; + void getThrowBoomerangID() const; + void getGrabActorID() const; + void checkGrabBarrel(); + void onFrollCrashFlg(u32); + void getOldSpeedY(); + void checkComboCutTurn() const; + void cancelChangeTextureAnime(); + void checkBoomerangAnime() const; + void throwBoomerang(); + void returnBoomerang(); + void checkNextActionBoomerangReady(); + void checkNextActionBoomerangFly(); + void checkNextBoomerangMode(); + void changeBoomerangCatchProc(); + void procBoomerangSubject_init(); + void procBoomerangSubject(); + void procBoomerangMove_init(); + void procBoomerangMove(); + void procBoomerangCatch_init(); + void procBoomerangCatch(); + void bowJointCB(int); + void bowButton() const; + void checkBowReadyAnime() const; + void checkBowAnime() const; + void makeArrow(); + void deleteArrow(); + void setBowReadyAnime(); + void setBowReloadAnime(); + void checkNextActionBowReady(); + void checkNextActionBowFly(); + void checkNextBowMode(); + void setBowModel(); + void procBowSubject_init(); + void procBowSubject(); + void procBowMove_init(); + void procBowMove(); + void checkHookshotReturn(); + void setHookshotCarryOffset(u32, cXyz const*); + void setHookshotModel(); + void setHookshotSight(); + void freeHookshotItem(); + void checkNextActionHookshotReady(); + void checkNextHookshotMode(); + void procHookshotSubject_init(); + void procHookshotSubject(); + void procHookshotMove_init(); + void procHookshotMove(); + void procHookshotFly_init(); + void procHookshotFly(); + void fanWindEffectDraw(); + void fanWindCrashEffectDraw(); + void fanJointCB(int); + void parachuteJointCB(int); + void setShapeFanLeaf(); + void checkFanGlideProc(int); + void setFanModel(); + void setSmallFanModel(); + void setParachuteFanModel(f32); + void procFanSwing_init(); + void procFanSwing(); + void procFanGlide_init(int); + void procFanGlide(); + void getDayNightParamData(); + void setTactModel(); + void checkNpcStatus(); + void getTactPlayRightArmAnm(s32); + void getTactPlayLeftArmAnm(s32); + void checkEndTactMusic() const; + void getTactMetronomeRate(); + void checkTactLastInput(); + void setTactZev(u32, int, char*); + void getTactTopPos(cXyz*); + void getTactNormalWait() const; + void getTactMusic() const; + void getTactTimerCancel() const; + void checkTactPlayMelody(); + void resetTactCount(); + void procTactWait_init(int); + void procTactWait(); + void procTactPlay_init(s32, int, int); + void procTactPlay(); + void procTactPlayEnd_init(int); + void procTactPlayEnd(); + void procTactPlayOriginal_init(); + void procTactPlayOriginal(); + void checkJumpFlower(); + void procVomitReady_init(s16, f32); + void procVomitReady(); + void procVomitWait_init(); + void procVomitWait(); + void procVomitJump_init(int); + void procVomitJump(); + void procVomitLand_init(); + void procVomitLand(); + void setHammerModel(); + void setHammerQuake(cBgS_PolyInfo*, cXyz const*, int); + void setHammerWaterSplash(); + void procHammerSideSwing_init(); + void procHammerSideSwing(); + void procHammerFrontSwingReady_init(); + void procHammerFrontSwingReady(); + void procHammerFrontSwing_init(); + void procHammerFrontSwing(); + void procHammerFrontSwingEnd_init(); + void procHammerFrontSwingEnd(); + void setPushPullKeepData(dBgW::PushPullLabel); + void procPushPullWait_init(int); + void procPushPullWait(); + void procPushMove_init(); + void procPushMove(); + void procPullMove_init(); + void procPullMove(); + void changeBottleDrinkFace(int); + void setBottleModel(u16); + void makeFairy(cXyz*, u32); + void procBottleDrink_init(u16); + void procBottleDrink(); + void procBottleOpen_init(u16); + void procBottleOpen(); + void procBottleSwing_init(int); + void procBottleSwing(); + void procBottleGet_init(); + void procBottleGet(); + void setEnemyWeaponAtParam(int); + void procWeaponNormalSwing_init(); + void procWeaponNormalSwing(); + void procWeaponSideSwing_init(); + void procWeaponSideSwing(); + void procWeaponFrontSwingReady_init(); + void procWeaponFrontSwingReady(); + void procWeaponFrontSwing_init(); + void procWeaponFrontSwing(); + void procWeaponFrontSwingEnd_init(); + void procWeaponFrontSwingEnd(); + void procWeaponThrow_init(); + void procWeaponThrow(); + void setHyoiModel(); + void procFoodThrow_init(); + void procFoodThrow(); + void procFoodSet_init(); + void procFoodSet(); + void setSwordModel(int); + void setLightSaver(); + void checkDemoShieldNoDraw(); + void checkDemoSwordNoDraw(int); + void checkChanceMode(); + void checkCutRollChange() const; + void getSwordBlurColor(); + void setNormalCutAtParam(u8); + void setFinishCutAtParam(u8); + void setExtraCutAtParam(u8); + void setExtraFinishCutAtParam(u8); + void setJumpCutAtParam(); + void getCutDirection(); + void changeCutProc(); + void changeCutReverseProc(daPy_lk_c::daPy_ANM); + void procCutA_init(s16); + void procCutA(); + void procCutF_init(s16); + void procCutF(); + void procCutR_init(s16); + void procCutR(); + void procCutL_init(s16); + void procCutL(); + void procCutEA_init(); + void procCutEA(); + void procCutEB_init(); + void procCutEB(); + void procCutExA_init(); + void procCutExA(); + void procCutExB_init(); + void procCutExB(); + void procCutTurn_init(int); + void procCutTurn(); + void procCutRoll_init(); + void procCutRoll(); + void procCutRollEnd_init(); + void procCutRollEnd(); + void procCutTurnCharge_init(); + void procCutTurnCharge(); + void procCutTurnMove_init(); + void procCutTurnMove(); + void procCutReverse_init(daPy_lk_c::daPy_ANM); + void procCutReverse(); + void procJumpCut_init(int); + void procJumpCut(); + void procJumpCutLand_init(); + void procJumpCutLand(); + void procCutExMJ_init(int); + void procCutExMJ(); + void procCutKesa_init(); + void procCutKesa(); + void checkNoControll() const; + /* 0x0320 */ request_of_phase_process_class mPhsLoad; - - /* 0x0328 */ u8 temp0[0x3480 - 0x0328]; - + /* 0x0328 */ J3DModelData* mpModelData; + /* 0x032C */ J3DModel* mpCLModel; + /* 0x0330 */ J3DModel* mpKatsuraModel; + /* 0x0334 */ J3DModel* mpYamuModel; + /* 0x0338 */ u8 field_0x0338[0x035C - 0x0338]; + /* 0x035C */ J3DAnmTexPattern* field_0x035c; + /* 0x0360 */ u8 field_0x0360[0x0364 - 0x0360]; + /* 0x0364 */ J3DAnmTextureSRTKey* mpTexScrollResData; + /* 0x0368 */ J3DTexMtxAnm* mpTexMtxAnm; + /* 0x036C */ daPy_matAnm_c* mpTexEyeScroll[2]; + /* 0x0374 */ J3DShape* mpZOffBlendShape[4]; + /* 0x0384 */ J3DShape* mpZOffNoneShape[4]; + /* 0x0394 */ J3DShape* mpZOnShape[4]; + /* 0x03A4 */ J3DShape* field_0x03a4; + /* 0x03A8 */ J3DShape* field_0x03a8; + /* 0x03AC */ dBgS_AcchCir mAcchCir[3]; + /* 0x046C */ dBgS_Acch mAcch; + /* 0x0630 */ dBgS_LinkLinChk mLinkLinChk; + /* 0x069C */ dBgS_RopeLinChk mRopeLinChk; + /* 0x0708 */ dBgS_BoomerangLinChk mBoomerangLinChk; + /* 0x0774 */ dBgS_LinkGndChk mGndChk; + /* 0x07C8 */ dBgS_LinkRoofChk mRoofChk; + /* 0x080C */ void* field_0x080c; + /* 0x0810 */ void* field_0x0810; + /* 0x0814 */ dBgS_ArrowLinChk mArrowLinChk; + /* 0x0880 */ dBgS_MirLightLinChk mMirLightLinChk; + /* 0x08EC */ u8 field_0x08EC[0x0910 - 0x08EC]; + /* 0x0910 */ cXyz field_0x0910; + /* 0x091C */ u8 field_0x091C[0x0950 - 0x091C]; + /* 0x0950 */ daPy_HIO_c* mpHIO; + /* 0x0954 */ J3DModel* mpHandsModel; + /* 0x0958 */ J3DModel* mpEquippedSwordModel; + /* 0x095C */ J3DModel* mpSwgripaModel; + /* 0x0960 */ J3DModel* mpSwgripmsModel; + /* 0x0964 */ mDoExt_bckAnm mSwgripmsabBckAnim; + /* 0x0974 */ J3DAnmTevRegKey* mpTswgripmsabBrkData; + /* 0x0978 */ J3DAnmTextureSRTKey* mpTswgripmsBtkData; + /* 0x097C */ J3DModel* mpPodmsModel; + /* 0x0980 */ J3DModel* mpEquippedShieldModel; + /* 0x0984 */ J3DModel* mpShaModel; + /* 0x0988 */ J3DModel* mpShmsModel; + /* 0x098C */ mDoExt_bckAnm field_0x098c; + /* 0x099C */ J3DAnmTextureSRTKey* field_0x099c; + /* 0x09A0 */ dDlst_mirrorPacket mMirrorPacket; + /* 0x2E7C */ J3DModel* mpYmsls00Model; + /* 0x2E80 */ J3DAnmTextureSRTKey* mpYmsls00BtkData; + /* 0x2E84 */ J3DModel* mpHbootsModelRightFoot; + /* 0x2E88 */ J3DModel* mpHbootsModelLeftFoot; + /* 0x2E8C */ J3DModel* mpPringModel; + /* 0x2E90 */ JKRSolidHeap* field_0x2e90; + /* 0x2E94 */ u8 field_0x2E94[0x2E98 - 0x2E94]; + /* 0x2E98 */ J3DModel* mpHeldItemModel; + /* 0x2E9C */ mDoExt_bckAnm mSwordAnim; + /* 0x2EAC */ u8 field_0x2EAC[0x2EB0 - 0x2EAC]; + /* 0x2EB0 */ J3DAnmTevRegKey* field_0x2eb0; + /* 0x2EB4 */ J3DAnmTevRegKey* mpGwp00BrkData; + /* 0x2EB8 */ J3DAnmTextureSRTKey* mpGwp00BtkData; + /* 0x2EBC */ u8 field_0x2EBC[0x2ED4 - 0x2EBC]; + /* 0x2ED4 */ J3DAnmTextureSRTKey* mpHeldItemModelAnimTexEx; + /* 0x2ED8 */ J3DAnmTextureSRTKey* mpSwordAnimBTK; + /* 0x2EDC */ J3DAnmTevRegKey* mpHeldItemAnimBRK; + /* 0x2EE0 */ J3DModel* mpBottleContentsModel; + /* 0x2EE4 */ J3DModel* mpBottleCapModel; + /* 0x2EE8 */ J3DModel* mpSwordModel1; + /* 0x2EEC */ u8 field_0x2EEC[0x2EF0 - 0x2EEC]; + /* 0x2EF0 */ J3DAnmColor* field_0x2ef0; + /* 0x2EF4 */ J3DAnmTextureSRTKey* field_0x2ef4; + /* 0x2EF8 */ J3DAnmTevRegKey* field_0x2ef8; + /* 0x2EFC */ mDoExt_brkAnm field_0x2efc; + /* 0x2F14 */ J3DModel* mpSuimenMunyaModel; + /* 0x2F18 */ J3DAnmTextureSRTKey* field_0x2f18; + /* 0x2F1C */ J3DModel* mpYuchw00Model; + /* 0x2F20 */ mDoExt_bckAnm field_0x2f20; + /* 0x2F30 */ J3DAnmTextureSRTKey* field_0x2f30; + /* 0x2F34 */ J3DAnmTevRegKey* field_0x2f34; + /* 0x2F38 */ J3DModel* mpYbafo00Model; + /* 0x2F3C */ J3DAnmTextureSRTKey* field_0x2f3c; + /* 0x2F40 */ MagicArmorAuraEntry mMagicArmorAuraEntries[6]; + /* 0x2F70 */ mDoExt_brkAnm field_0x2f70; + /* 0x2F88 */ u8 field_0x2F88[0x2F8C - 0x2F88]; + /* 0x2F8C */ J3DModel* mpYmgcs00Model; + /* 0x2F90 */ mDoExt_brkAnm field_0x2f90; + /* 0x2FA8 */ u8 field_0x2FA8[0x2FAC - 0x2FA8]; + /* 0x2FAC */ J3DMtxCalc* field_0x2fac; + /* 0x2FB0 */ J3DMtxCalc* field_0x2fb0; + /* 0x2FB4 */ mDoExt_AnmRatioPack field_0x2fb4[2]; + /* 0x2FC4 */ mDoExt_AnmRatioPack field_0x2fc4[3]; + /* 0x2FDC */ daPy_anmHeap_c field_0x2fdc[2]; + /* 0x2FFC */ daPy_anmHeap_c field_0x2ffc[3]; + /* 0x302C */ J3DFrameCtrl field_0x302c[2]; + /* 0x3054 */ J3DFrameCtrl field_0x3054[3]; + /* 0x3090 */ daPy_sightPacket_c mSightPacket; + /* 0x30E0 */ JAIZelAnime mJAIZelAnime; + /* 0x3178 */ u8 field_0x3178[0x317C - 0x3178]; + /* 0x317C */ daPy_actorKeep_c mActorKeepEquip; + /* 0x3184 */ daPy_actorKeep_c mActorKeepThrow; + /* 0x318C */ daPy_actorKeep_c mActorKeepGrab; + /* 0x3194 */ daPy_actorKeep_c mActorKeepRope; + /* 0x319C */ fopAc_ac_c* mpAttnActorLockOn; + /* 0x31A0 */ fopAc_ac_c* mpAttnActorAction; + /* 0x31A4 */ fopAc_ac_c* mpAttnActorA; + /* 0x31A8 */ fopAc_ac_c* mpAttnActorX; + /* 0x31AC */ fopAc_ac_c* mpAttnActorY; + /* 0x31B0 */ fopAc_ac_c* mpAttnActorZ; + /* 0x31B4 */ mDoExt_MtxCalcOldFrame* field_0x31b4; + /* 0x31B8 */ s16 mTexAnimeResIdx; + /* 0x31BA */ s16 field_0x31ba; + /* 0x31BC */ s16 field_0x31bc; + /* 0x31BE */ u8 field_0x31BE[0x31C0 - 0x31BE]; + /* 0x31C0 */ void* mpTextureAnimeResData; + /* 0x31C4 */ JKRSolidHeap* mpTextureAnimeResHeap; + /* 0x31C8 */ u16 mTexScrollResIdx; + /* 0x31CA */ s16 field_0x31ca; + /* 0x31CC */ s16 field_0x31cc; + /* 0x31CE */ s16 field_0x31ce; + /* 0x31D0 */ void* mpTextureScrollResData; + /* 0x31D4 */ JKRSolidHeap* mpTextureScrollResHeap; + /* 0x31D8 */ u32 mCurProc; + /* 0x31DC */ int (daPy_lk_c::*field_0x31dc)(); + /* 0x31E8 */ daPy_footEffect_c field_0x31e8[2]; + /* 0x3280 */ u8 field_0x3280[0x3294 - 0x3280]; + /* 0x3294 */ daPy_swimTailEcallBack_c mSwimTailEcallBack[2]; + /* 0x32E4 */ daPy_mtxFollowEcallBack_c field_0x32e4; + /* 0x32F0 */ daPy_mtxFollowEcallBack_c field_0x32f0; + /* 0x32FC */ dPa_smokeEcallBack mSmokeEcallBack; + /* 0x331C */ dPa_cutTurnEcallBack_c mCutTurnEcallBack[3]; + /* 0x334C */ daPy_waterDropEcallBack_c mWaterDropEcallBack[2]; + /* 0x338C */ daPy_followEcallBack_c field_0x338c; + /* 0x33A8 */ daPy_mtxFollowEcallBack_c field_0x33a8; + /* 0x33B4 */ u8 field_0x33B4[0x33B8 - 0x33B4]; + /* 0x33B8 */ daPy_dmEcallBack_c field_0x33b8[4]; + /* 0x33E8 */ u8 field_0x33E8[0x3460 - 0x33E8]; + /* 0x3460 */ daPy_mtxPosFollowEcallBack_c field_0x3460[2]; /* 0x3480 */ dAttention_c* mpAttention; /* 0x3484 */ dAttList_c* mpAttnEntryA; /* 0x3488 */ dAttList_c* mpAttnEntryX; @@ -155,6 +1347,17 @@ public: /* 0x3730 */ u8 field_0x3730[0x3748 - 0x3730]; /* 0x3748 */ cXyz field_0x3748; /* 0x3754 */ u8 field_0x3754[0x37E4 - 0x3754]; + /* 0x37E4 */ daPy_swBlur_c mSwBlur; + /* 0x3DB8 */ daPy_footData_c mFootData[2]; + /* 0x3FE8 */ dCcD_Stts field_0x3fe8; + /* 0x4024 */ dCcD_Cyl field_0x4024; + /* 0x4154 */ dCcD_Cyl field_0x4154; + /* 0x4284 */ dCcD_Cyl field_0x4284; + /* 0x43B4 */ dCcD_Cyl field_0x43b4; + /* 0x44E4 */ dCcD_Cps field_0x44e4[3]; + /* 0x488C */ dCcD_Cps field_0x488c; + /* 0x49C4 */ dCcD_Sph field_0x49c4; + /* 0x4AF0 */ dCcD_Cps field_0x4af0; }; #endif /* D_D_A_PLAYER_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_acch.h b/include/d/d_bg_s_acch.h new file mode 100644 index 000000000..509b15bd5 --- /dev/null +++ b/include/d/d_bg_s_acch.h @@ -0,0 +1,208 @@ +#ifndef D_BG_D_BG_S_ACCH_H +#define D_BG_D_BG_S_ACCH_H + +#include "SSystem/SComponent/c_m3d_g_cir.h" +#include "SSystem/SComponent/c_m3d_g_cyl.h" +#include "SSystem/SComponent/c_m3d_g_lin.h" +#include "SSystem/SComponent/c_m3d_g_pla.h" +#include "d/d_bg_s_gnd_chk.h" +#include "d/d_bg_s_roof_chk.h" +#include "d/d_bg_s_wtr_chk.h" +#include "SSystem/SComponent/c_sxyz.h" + +class fopAc_ac_c; + +class dBgS_AcchCir : public cBgS_PolyInfo { +private: + /* 0x10 */ u32 m_flags; + /* 0x14 */ cM3dGCir m_cir; + /* 0x28 */ f32 m_wall_rr; + /* 0x2C */ f32 field_0x2c; + /* 0x30 */ f32 m_wall_h; + /* 0x34 */ f32 m_wall_r; + /* 0x38 */ f32 m_wall_h_direct; + /* 0x3C */ s16 m_wall_angle_y; + +public: + enum { + /* 0x2 */ WALL_HIT = 2, + /* 0x4 */ WALL_H_DIRECT = 4, + }; + + /* 80075EAC */ dBgS_AcchCir(); + /* 80075F14 */ void ClrWallHit(); + /* 80075F40 */ void SetWallR(f32); + /* 80075F48 */ void CalcWallRR(); + /* 80075F58 */ void SetWall(f32, f32); + /* 80075F80 */ void SetWallHDirect(f32); + + /* 80077414 */ virtual ~dBgS_AcchCir() {} + + f32 GetWallH() { return m_wall_h; } + f32 GetWallR() { return m_wall_r; } + void SetWallH(f32 h) { m_wall_h = h; } + void ClrWallHDirect() { m_flags &= ~WALL_H_DIRECT; } + bool ChkWallHit() { return m_flags & WALL_HIT; } + + void SetCir(cXyz& pos) { m_cir.Set(pos.x, pos.z, pos.y + GetWallH(), m_wall_r); } +}; // Size: 0x40 + +class dBgS; +class dBgS_Acch : public cBgS_Chk, public dBgS_Chk { +public: + enum { + /* 0x000002 */ GRND_NONE = (1 << 1), + /* 0x000004 */ WALL_NONE = (1 << 2), + /* 0x000008 */ ROOF_NONE = (1 << 3), + /* 0x000010 */ WALL_HIT = (1 << 4), + /* 0x000020 */ GROUND_HIT = (1 << 5), + /* 0x000040 */ GROUND_FIND = (1 << 6), + /* 0x000080 */ GROUND_LANDING = (1 << 7), + /* 0x000100 */ GROUND_AWAY = (1 << 8), + /* 0x000200 */ ROOF_HIT = (1 << 9), + /* 0x000400 */ WATER_NONE = (1 << 10), + /* 0x000800 */ WATER_HIT = (1 << 11), + /* 0x001000 */ WATER_IN = (1 << 12), + /* 0x002000 */ LINE_CHECK = (1 << 13), + /* 0x004000 */ LINE_CHECK_NONE = (1 << 14), + /* 0x008000 */ CLR_SPEED_Y = (1 << 15), + /* 0x010000 */ LINE_CHECK_HIT = (1 << 16), + /* 0x100000 */ MOVE_BG_ONLY = (1 << 20), + /* 0x200000 */ GND_THIN_CELLING_OFF = (1 << 21), + /* 0x400000 */ WALL_SORT = (1 << 22), + /* 0x800000 */ LINE_DOWN = (1 << 23), + }; + + /* 800760A0 */ dBgS_Acch(); + /* 800761CC */ void Init(); + /* 80076288 */ void Set(fopAc_ac_c*, int, dBgS_AcchCir*); + /* 80076248 */ void Set(cXyz*, cXyz*, fopAc_ac_c*, int, dBgS_AcchCir*, cXyz*, csXyz*, csXyz*); + /* 800762D8 */ void GroundCheckInit(dBgS&); + /* 80076350 */ void GroundCheck(dBgS&); + /* 8007654C */ void GroundRoofProc(dBgS&); + /* 80076624 */ void LineCheck(dBgS&); + /* 80076AAC */ void CrrPos(dBgS&); + /* 80076F84 */ f32 GetWallAllR(); + /* 80076FC0 */ void SetWallCir(); + /* 8007703C */ void CalcWallBmdCyl(); + /* 80077114 */ void SetGroundUpY(f32); + /* 80077128 */ f32 GetWallAllLowH(); + /* 80077178 */ f32 GetWallAllLowH_R(); + /* 800771E4 */ f32 GetSpeedY(); + /* 80077200 */ f32 GetWallAddY(Vec&); + /* 80077278 */ void SetNowActorInfo(int, void*, unsigned int); + /* 80077288 */ void SetWallPolyIndex(int, int); + /* 800772E8 */ void CalcMovePosWork(); + /* 8007732C */ void CalcWallRR(); + /* 80077388 */ void SetMoveBGOnly(); + /* 800773A4 */ void ClrMoveBGOnly(); + /* 800773C0 */ void SetGndThinCellingOff(); + /* 800773D0 */ void ClrGndThinCellingOff(); + /* 800773E0 */ bool ChkGndThinCellingOff(); + /* 800773EC */ void OnWallSort(); + /* 800773FC */ bool ChkWallSort(); + /* 80077408 */ bool ChkLineDown(); + /* 800D00D0 */ bool ChkRoofHit() const; + /* 800D00DC */ void ClrGroundHit(); + /* 80141404 */ bool ChkGroundHit() const; + + /* 80075F94 */ virtual ~dBgS_Acch(); + + cXyz* GetPos() { return pm_pos; } + cXyz* GetOldPos() { return pm_old_pos; } + f32 GetGroundH() const { return m_ground_h; } + f32 GetRoofHeight() const { return m_roof_height; } + void SetLin() { m_lin.SetStartEnd(*pm_old_pos, *pm_pos); } + bool ChkGroundFind() { return m_flags & GROUND_FIND; } + bool ChkGroundHit() { return m_flags & GROUND_HIT; } + bool ChkGroundLanding() { return m_flags & GROUND_LANDING; } + void ClrGroundLanding() { m_flags &= ~GROUND_LANDING; } + void ClrGroundAway() { m_flags &= ~GROUND_AWAY; } + void ClrWallHit() { m_flags &= ~WALL_HIT; } + void SetRoofNone() { m_flags |= ROOF_NONE; } + void SetRoofHit() { m_flags |= ROOF_HIT; } + void SetWaterNone() { m_flags |= WATER_NONE; } + bool ChkWallHit() { return m_flags & WALL_HIT; } + void OffLineCheckHit() { m_flags &= ~LINE_CHECK_HIT; } + void OffLineCheck() { m_flags &= ~LINE_CHECK; } + bool ChkLineCheckNone() { return m_flags & LINE_CHECK_NONE; } + bool ChkLineCheck() { return m_flags & LINE_CHECK; } + void ClrRoofHit() { m_flags &= ~ROOF_HIT; } + void ClrWaterHit() { m_flags &= ~WATER_HIT; } + void SetWaterHit() { m_flags |= WATER_HIT; } + void ClrWaterIn() { m_flags &= ~WATER_IN; } + void SetWaterIn() { m_flags |= WATER_IN; } + const u32 MaskWaterIn() { return m_flags & WATER_IN; } + const bool ChkWaterIn() { return MaskWaterIn();} + void ClrGroundFind() { m_flags &= ~GROUND_FIND; } + u32 MaskRoofHit() { return m_flags & ROOF_HIT; } + bool ChkRoofHit() { return MaskRoofHit(); } + bool ChkClrSpeedY() { return m_flags & CLR_SPEED_Y; } + void SetGroundFind() { m_flags |= GROUND_FIND; } + void SetGroundHit() { m_flags |= GROUND_HIT; } + void SetGroundLanding() { m_flags |= GROUND_LANDING; } + void SetGroundAway() { m_flags |= GROUND_AWAY; } + const u32 MaskWaterHit() { return m_flags & WATER_HIT; } + const bool ChkWaterHit() { return MaskWaterHit(); } + void ClrWaterNone() { m_flags &= ~WATER_NONE; } + void OnLineCheck() { m_flags |= LINE_CHECK; } + void ClrRoofNone() { m_flags &= ~ROOF_NONE; } + void SetRoofCrrHeight(f32 height) { m_roof_crr_height = height; } + void SetGrndNone() { m_flags |= GRND_NONE; } + void ClrGrndNone() { m_flags &= ~GRND_NONE; } + bool ChkMoveBGOnly() const { return m_flags & MOVE_BG_ONLY; } + void SetWallHit() { m_flags |= WALL_HIT; } + void ClrWallNone() { m_flags &= ~WALL_NONE; } + cM3dGCyl* GetWallBmdCylP() { return &m_wall_cyl; } + +public: + /* 0x028 */ u32 m_flags; + /* 0x02C */ cXyz* pm_pos; + /* 0x030 */ cXyz* pm_old_pos; + /* 0x034 */ cXyz* pm_speed; + /* 0x038 */ csXyz* pm_angle; + /* 0x03C */ csXyz* pm_shape_angle; + /* 0x040 */ cM3dGLin m_lin; + /* 0x05C */ cM3dGCyl m_wall_cyl; + /* 0x074 */ int m_bg_index; + /* 0x078 */ void* field_0x7c; + /* 0x07C */ u32 field_0x80; + /* 0x080 */ fopAc_ac_c* m_my_ac; + /* 0x084 */ int m_tbl_size; + /* 0x088 */ dBgS_AcchCir* field_0x8c; + /* 0x08C */ f32 field_0x90; + /* 0x090 */ f32 field_0x94; + /* 0x094 */ f32 m_ground_h; + /* 0x098 */ f32 field_0x9c; + /* 0x09C */ cM3dGPla field_0xa0; + /* 0x0B0 */ u8 field_0xb4; + /* 0x0B4 */ f32 field_0xb8; + /* 0x0B8 */ f32 field_0xbc; + /* 0x0BC */ u8 field_0xc0; + /* 0x0C0 */ f32 m_roof_height; + /* 0x0C4 */ f32 m_roof_crr_height; + /* 0x0C8 */ f32 field_0xc8; + /* 0x0CC */ int field_0xd4; + /* 0x0D0 */ f32 field_0xd8; + /* 0x0D4 */ dBgS_GndChk m_gnd; + /* 0x128 */ dBgS_RoofChk m_roof; + /* 0x174 */ dBgS_WtrChk m_wtr; +}; // Size: 0x1C4 + +class dBgS_LinkAcch : public dBgS_Acch { +public: + dBgS_LinkAcch() { /* SetLink(); */ } + + /* 80140F30 */ virtual ~dBgS_LinkAcch(); +}; + +class dBgS_ObjAcch : public dBgS_Acch { +public: + dBgS_ObjAcch() { + /* SetObj(); */ + } + + /* 80BB336C */ virtual ~dBgS_ObjAcch() {} +}; + +#endif /* D_BG_D_BG_S_ACCH_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_chk.h b/include/d/d_bg_s_chk.h new file mode 100644 index 000000000..08c24f34d --- /dev/null +++ b/include/d/d_bg_s_chk.h @@ -0,0 +1,16 @@ +#ifndef D_BG_D_BG_S_CHK_H +#define D_BG_D_BG_S_CHK_H + +#include "d/d_bg_s_grp_pass_chk.h" +#include "d/d_bg_s_poly_pass_chk.h" + +class dBgS_Chk : public dBgS_PolyPassChk, public dBgS_GrpPassChk { +public: + dBgS_Chk(); + cBgS_PolyPassChk* GetPolyPassChkInfo(); + cBgS_GrpPassChk* GetGrpPassChkInfo(); + + virtual ~dBgS_Chk(); +}; // Size: 0x14 + +#endif /* D_BG_D_BG_S_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_gnd_chk.h b/include/d/d_bg_s_gnd_chk.h new file mode 100644 index 000000000..7c81b7350 --- /dev/null +++ b/include/d/d_bg_s_gnd_chk.h @@ -0,0 +1,61 @@ +#ifndef D_BG_D_BG_S_GND_CHK_H +#define D_BG_D_BG_S_GND_CHK_H + +#include "SSystem/SComponent/c_bg_s_gnd_chk.h" +#include "d/d_bg_s_chk.h" + +class dBgS_GndChk : public cBgS_GndChk, public dBgS_Chk { +public: + /* 8007757C */ dBgS_GndChk(); + /* 800775F0 */ virtual ~dBgS_GndChk(); +}; // Size: 0x54 + +class dBgS_LinkGndChk : public dBgS_GndChk { +public: + dBgS_LinkGndChk() { /* SetLink(); */ } + /* 80140EB8 */ virtual ~dBgS_LinkGndChk(); +}; + +class dBgS_ObjGndChk : public dBgS_GndChk { +public: + dBgS_ObjGndChk() { /* SetObj(); */ } + + /* 8001E020 */ virtual ~dBgS_ObjGndChk(); +}; + +class dBgS_ObjGndChk_Wtr : public dBgS_ObjGndChk { +public: + /* 80077678 */ dBgS_ObjGndChk_Wtr(); + + /* 80077710 */ virtual ~dBgS_ObjGndChk_Wtr(); +}; + +class dBgS_ObjGndChk_Spl : public dBgS_ObjGndChk { +public: + /* 800777B0 */ dBgS_ObjGndChk_Spl(); + + /* 80077848 */ virtual ~dBgS_ObjGndChk_Spl(); +}; + +class dBgS_ObjGndChk_All : public dBgS_ObjGndChk { +public: + /* 800778E8 */ virtual ~dBgS_ObjGndChk_All(); + + dBgS_ObjGndChk_All() { /* OnAll(); */ } +}; + +class dBgS_CamGndChk : public dBgS_GndChk { +public: + dBgS_CamGndChk() { /* SetCam(); */ } + + /* 80077988 */ virtual ~dBgS_CamGndChk(); +}; + +class dBgS_CamGndChk_Wtr : public dBgS_CamGndChk { +public: + /* 80077A00 */ dBgS_CamGndChk_Wtr(); + + /* 80077A98 */ virtual ~dBgS_CamGndChk_Wtr(); +}; + +#endif /* D_BG_D_BG_S_GND_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_grp_pass_chk.h b/include/d/d_bg_s_grp_pass_chk.h new file mode 100644 index 000000000..3e8960337 --- /dev/null +++ b/include/d/d_bg_s_grp_pass_chk.h @@ -0,0 +1,30 @@ +#ifndef D_BG_D_BG_S_GRP_PASS_CHK_H +#define D_BG_D_BG_S_GRP_PASS_CHK_H + +#include "SSystem/SComponent/c_bg_s_chk.h" + +class dBgS_GrpPassChk : public cBgS_GrpPassChk { +public: + enum { + /* 0x1 */ NORMAL_GRP = 1, + /* 0x2 */ WATER_GRP, + /* 0x3 */ FULL_GRP + }; + + /* 80077BA0 */ dBgS_GrpPassChk(); + + /* 80077BC4 */ virtual ~dBgS_GrpPassChk(); + + void OnWaterGrp() { mGrp |= WATER_GRP; } + void OnSpl() { mGrp |= WATER_GRP; } + void OnNormalGrp() { mGrp |= NORMAL_GRP; } + void OffNormalGrp() { mGrp &= ~NORMAL_GRP; } + void OffFullGrp() { mGrp &= ~FULL_GRP; } + void OnAll() { mGrp |= FULL_GRP; } + u32 MaskNormalGrp() const {return mGrp & 1; } + u32 MaskWaterGrp() const {return mGrp & 2; } +private: + /* 0x4 */ u32 mGrp; +}; + +#endif /* D_BG_D_BG_S_GRP_PASS_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_lin_chk.h b/include/d/d_bg_s_lin_chk.h new file mode 100644 index 000000000..bda6674e8 --- /dev/null +++ b/include/d/d_bg_s_lin_chk.h @@ -0,0 +1,83 @@ +#ifndef D_BG_D_BG_S_LIN_CHK_H +#define D_BG_D_BG_S_LIN_CHK_H + +#include "SSystem/SComponent/c_bg_s_lin_chk.h" +#include "d/d_bg_s_chk.h" + +class fopAc_ac_c; + +class dBgS_LinChk : public cBgS_LinChk, public dBgS_Chk { +public: + /* 80077C68 */ dBgS_LinChk(); + /* 80077D64 */ void Set(cXyz const* pi_start, cXyz const* pi_end, fopAc_ac_c const*); + + /* 80077CDC */ virtual ~dBgS_LinChk(); + + /* 0x00 cBgS_LinChk */; + /* 0x58 dBgS_Chk */; +}; + +class dBgS_LinkLinChk : public dBgS_LinChk { +public: + /* 80078030 */ dBgS_LinkLinChk(); + + /* 8007808C */ virtual ~dBgS_LinkLinChk(); +}; + +class dBgS_RopeLinChk : public dBgS_LinChk { +public: + /* 8007838C */ dBgS_RopeLinChk(); + + /* 800783E8 */ virtual ~dBgS_RopeLinChk(); +}; + +class dBgS_BoomerangLinChk : public dBgS_LinChk { +public: + /* 800782B8 */ dBgS_BoomerangLinChk(); + + /* 80078314 */ virtual ~dBgS_BoomerangLinChk(); +}; + +class dBgS_ArrowLinChk : public dBgS_LinChk { +public: + /* 800781D8 */ dBgS_ArrowLinChk(); + + /* 80078240 */ virtual ~dBgS_ArrowLinChk(); +}; + +class dBgS_ObjLinChk : public dBgS_LinChk { +public: + /* 80077F5C */ dBgS_ObjLinChk(); + + /* 80077FB8 */ virtual ~dBgS_ObjLinChk(); +}; + +class dBgS_BombLinChk : public dBgS_LinChk { +public: + /* 80078104 */ dBgS_BombLinChk(); + + /* 80078160 */ virtual ~dBgS_BombLinChk(); +}; + +class dBgS_CamLinChk : public dBgS_LinChk { +public: + /* 80077DA4 */ dBgS_CamLinChk(); + + /* 80077E00 */ virtual ~dBgS_CamLinChk(); +}; + +class dBgS_CamLinChk_NorWtr : public dBgS_CamLinChk { +public: + /* 80077E78 */ dBgS_CamLinChk_NorWtr(); + + /* 80077EE4 */ virtual ~dBgS_CamLinChk_NorWtr(); +}; + +class dBgS_MirLightLinChk : public dBgS_LinChk { +public: + dBgS_MirLightLinChk(); + + virtual ~dBgS_MirLightLinChk(); +}; + +#endif /* D_BG_D_BG_S_LIN_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_poly_pass_chk.h b/include/d/d_bg_s_poly_pass_chk.h new file mode 100644 index 000000000..4b0c596bc --- /dev/null +++ b/include/d/d_bg_s_poly_pass_chk.h @@ -0,0 +1,17 @@ +#ifndef D_BG_D_BG_S_POLY_PASS_CHK_H +#define D_BG_D_BG_S_POLY_PASS_CHK_H + +#include "dolphin/types.h" + +class cBgS_PolyPassChk { +public: + virtual ~cBgS_PolyPassChk(); +}; + +class dBgS_PolyPassChk : public cBgS_PolyPassChk { +public: + dBgS_PolyPassChk(); + virtual ~dBgS_PolyPassChk(); +}; + +#endif /* D_BG_D_BG_S_POLY_PASS_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_roof_chk.h b/include/d/d_bg_s_roof_chk.h new file mode 100644 index 000000000..b91037ac0 --- /dev/null +++ b/include/d/d_bg_s_roof_chk.h @@ -0,0 +1,29 @@ +#ifndef D_BG_D_BG_S_ROOF_CHK_H +#define D_BG_D_BG_S_ROOF_CHK_H + +#include "SSystem/SComponent/c_bg_s_poly_info.h" +#include "SSystem/SComponent/c_xyz.h" +#include "d/d_bg_s_chk.h" + +class dBgS_RoofChk : public cBgS_PolyInfo, public cBgS_Chk, public dBgS_Chk { +public: + /* 80078FF4 */ dBgS_RoofChk(); + /* 80079124 */ void Init(); + /* 800B146C */ void SetPos(cXyz const&); + + /* 80079090 */ virtual ~dBgS_RoofChk(); + + void i_SetPos(cXyz const& pos) { m_pos = pos; } + cXyz* GetPosP() { return &m_pos; } + +private: + /* 0x38 */ cXyz m_pos; +}; // Size: 0x44 + +class dBgS_LinkRoofChk : public dBgS_RoofChk { +public: + dBgS_LinkRoofChk() { /* SetLink(); */ } + /* 80140E40 */ virtual ~dBgS_LinkRoofChk(); +}; + +#endif /* D_BG_D_BG_S_ROOF_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_spl_grp_chk.h b/include/d/d_bg_s_spl_grp_chk.h new file mode 100644 index 000000000..f9df12a96 --- /dev/null +++ b/include/d/d_bg_s_spl_grp_chk.h @@ -0,0 +1,40 @@ +#ifndef D_BG_D_BG_S_SPL_GRP_CHK_H +#define D_BG_D_BG_S_SPL_GRP_CHK_H + +#include "SSystem/SComponent/c_bg_s_poly_info.h" +#include "SSystem/SComponent/c_xyz.h" +#include "d/d_bg_s_chk.h" + +class dBgS_SplGrpChk : public cBgS_PolyInfo, public cBgS_Chk, public dBgS_Chk { +public: + enum { + /* 0x1 */ FIND = 1, + /* 0x2 */ IN = 2, + /* 0x4 */ MOVE_BG_ONLY = 4 + }; + + /* 80078B90 */ void Set(cXyz&, f32); + /* 80078BB0 */ dBgS_SplGrpChk(); + /* 80078D0C */ void Init(); + + /* 80078C78 */ virtual ~dBgS_SplGrpChk(); + + void OffFind() { m_flags &= ~FIND; } + void OffIn() { m_flags &= ~IN; } + void OffMoveBGOnly() { m_flags &= ~MOVE_BG_ONLY; } + void OnMoveBGOnly() { m_flags |= MOVE_BG_ONLY; } + void OnFind() { m_flags |= FIND; } + bool ChkMoveBGOnly() { return m_flags & MOVE_BG_ONLY; } + void SetHeight(f32 height) { m_height = height; } + f32 GetHeight() { return m_height; } + cXyz& GetPosP() { return m_ground; } + f32 GetRoof() const { return m_roof; } + +private: + /* 0x38 */ cXyz m_ground; + /* 0x44 */ f32 m_roof; + /* 0x48 */ f32 m_height; + /* 0x4C */ u32 m_flags; +}; // Size: 0x50 + +#endif /* D_BG_D_BG_S_SPL_GRP_CHK_H */ \ No newline at end of file diff --git a/include/d/d_bg_s_wtr_chk.h b/include/d/d_bg_s_wtr_chk.h new file mode 100644 index 000000000..ce70935e7 --- /dev/null +++ b/include/d/d_bg_s_wtr_chk.h @@ -0,0 +1,13 @@ +#ifndef D_BG_D_BG_S_WTR_CHK_H +#define D_BG_D_BG_S_WTR_CHK_H + +#include "d/d_bg_s_spl_grp_chk.h" + +class dBgS_WtrChk : public dBgS_SplGrpChk { +public: + /* 80079164 */ dBgS_WtrChk(); + + /* 8001DF30 */ virtual ~dBgS_WtrChk(); +}; // Size: 0x50 + +#endif /* D_BG_D_BG_S_WTR_CHK_H */ \ No newline at end of file diff --git a/include/d/d_cc_d.h b/include/d/d_cc_d.h new file mode 100644 index 000000000..b672b3e0c --- /dev/null +++ b/include/d/d_cc_d.h @@ -0,0 +1,395 @@ +#ifndef D_CC_D_CC_D_H +#define D_CC_D_CC_D_H + +/** + * d_cc_d.h + * Actor Collision + */ + +#include "SSystem/SComponent/c_cc_d.h" + +enum dCcD_hitSe {}; + +enum dCcG_At_Spl {}; + +enum dCcG_Tg_Spl {}; + +struct dCcD_SrcGAtTgCoCommonBase { + /* 0x0 */ u32 mGFlag; +}; // Size: 0x4 + +struct dCcD_SrcGObjAt { + /* 0x0 */ u8 mSe; // Sound Effect ID + /* 0x1 */ u8 mHitMark; // Hit Mark particle ID + /* 0x2 */ u8 mSpl; + /* 0x3 */ u8 mMtrl; + /* 0x4 */ dCcD_SrcGAtTgCoCommonBase mBase; +}; // Size: 0x8 + +struct dCcD_SrcGObjTg { + /* 0x0 */ u8 mSe; // Sound Effect ID + /* 0x1 */ u8 mHitMark; // Hit Mark particle ID + /* 0x2 */ u8 mSpl; + /* 0x3 */ u8 mMtrl; + /* 0x4 */ dCcD_SrcGAtTgCoCommonBase mBase; +}; // Size: 0x8 + +struct dCcD_SrcGObjCo { + /* 0x0 */ dCcD_SrcGAtTgCoCommonBase mBase; +}; // Size: 0x4 + +struct dCcD_SrcGObjInf { + /* 0x00 */ cCcD_SrcObj mObj; + /* 0x1C */ dCcD_SrcGObjAt mGObjAt; + /* 0x24 */ dCcD_SrcGObjTg mGObjTg; + /* 0x2C */ dCcD_SrcGObjCo mGObjCo; +}; // Size: 0x30 + +struct dCcD_SrcSph { + /* 0x00 */ dCcD_SrcGObjInf mObjInf; + /* 0x30 */ cCcD_SrcSphAttr mSphAttr; +}; // Size: 0x40 + +struct dCcD_SrcTri { + /* 0x00 */ dCcD_SrcGObjInf mObjInf; + /* 0x30 */ cCcD_SrcTriAttr mTriAttr; +}; // Size: 0x54 + +struct dCcD_SrcCyl { + /* 0x00 */ dCcD_SrcGObjInf mObjInf; + /* 0x30 */ cM3dGCylS mCyl; +}; // Size: 0x44 + +struct dCcD_SrcCps { + /* 0x00 */ dCcD_SrcGObjInf mObjInf; + /* 0x30 */ cCcD_SrcCpsAttr mCpsAttr; +}; // Size: 0x4C + +class dCcD_GStts : public cCcD_GStts { +public: + dCcD_GStts(); + virtual ~dCcD_GStts() {} + + void Ct(); + void Move(); + void ClrAt() { mAt = 0; } + void ClrTg() { mTg = 0; } + void SetAtApid(unsigned int id) { mAtApid = id; } + void SetTgApid(unsigned int id) { mTgApid = id; } + u8 GetRoomId() { return mRoomId; } + void SetRoomId(int id) { mRoomId = id; } + unsigned int GetAtOldApid() { return mAtOldApid; } + unsigned int GetTgOldApid() { return mTgOldApid; } + bool ChkNoActor() { return field_0x1C & 1; } + bool ChkNoneActorPerfTblId() { return field_0x08 == 0xFFFF; } + dCcG_At_Spl GetAtSpl() { return (dCcG_At_Spl)mAt; } + void SetAtSpl(dCcG_At_Spl spl) { mAt = spl; } + dCcG_Tg_Spl GetTgSpl() { return (dCcG_Tg_Spl)mTg; } + void SetTgSpl(dCcG_Tg_Spl spl) { mTg = spl; } + void OnNoActor() { field_0x1C |= 1; } + + // private: + /* 0x04 */ u8 mAt; + /* 0x05 */ u8 mTg; + /* 0x06 */ u8 mRoomId; + /* 0x08 */ u16 field_0x08; + /* 0x0C */ int mAtApid; + /* 0x10 */ int mAtOldApid; + /* 0x14 */ int mTgApid; + /* 0x18 */ int mTgOldApid; + /* 0x1C */ int field_0x1C; +}; // Size = 0x20 + +class dCcD_Stts : public cCcD_Stts, public dCcD_GStts { +public: + dCcD_Stts() {} + virtual cCcD_GStts* GetGStts(); + void Init(int, int, fopAc_ac_c*); + virtual void Ct(); + virtual void ClrAt(); + virtual void ClrTg(); + virtual ~dCcD_Stts() {} + +}; // Size = 0x3C + +class dCcD_GObjInf; +typedef void (*dCcD_HitCallback)(fopAc_ac_c*, dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*); + +// Attack/Defense/Correction Collider Common Base +class dCcD_GAtTgCoCommonBase { +public: + /* 0x00 */ u32 mGFlag; + /* 0x04 */ u32 mRPrm; + /* 0x08 */ dCcD_HitCallback mHitCallback; + /* 0x0C */ u32 mApid; + /* 0x10 */ fopAc_ac_c* mAc; + /* 0x14 */ s8 mEffCounter; + /* 0x15 */ u8 field_0x15[3]; + /* 0x18 vtable */ + +public: + dCcD_GAtTgCoCommonBase() { ct(); } + void ClrActorInfo(); + void ct(); + void SetHitApid(unsigned int); + fopAc_ac_c* GetAc(); + void Set(dCcD_SrcGAtTgCoCommonBase const&); + void SetEffCounterTimer(); + void SubtractEffCounter(); + bool ChkEffCounter(); + virtual ~dCcD_GAtTgCoCommonBase() {} + + void ClrEffCounter() { mEffCounter = 0; } + u32 GetGFlag() const { return mGFlag; } + u32 GetRPrm() const { return mRPrm; } + u32 MskSPrm(u32 mask) const { return mGFlag & mask; } + u32 MskRPrm(u32 mask) const { return mRPrm & mask; } + bool ChkSPrm(u32 mask) const { return MskSPrm(mask); } + void OnSPrm(u32 flag) { mGFlag |= flag; } + void OnRPrm(u32 flag) { mRPrm |= flag; } + void OffSPrm(u32 flag) { mGFlag &= ~flag; } + void OffRPrm(u32 flag) { mRPrm &= ~flag; } + bool ChkRPrm(u32 flag) const { return MskRPrm(flag); } + void SetHitCallback(dCcD_HitCallback callback) { mHitCallback = callback; } + dCcD_HitCallback GetHitCallback() { return mHitCallback; } + void ClrHit() { ClrActorInfo(); } +}; // Size = 0x1C + +// Attack (At) Collider +class dCcD_GObjAt : public dCcD_GAtTgCoCommonBase { +public: + void Set(dCcD_SrcGObjAt const&); + virtual ~dCcD_GObjAt() {} + void SetVec(cXyz& vec) { mVec = vec; } + cXyz& GetVec() { return mVec; } + cXyz* GetVecP() { return &mVec; } + void SetHitMark(u8 mark) { mHitMark = mark; } + void SetSe(u8 se) { mSe = se; } + void SetMtrl(u8 mtrl) { mMtrl = mtrl; } + void SetAtSpl(dCcG_At_Spl spl) { mSpl = spl; } + u8 GetSe() { return mSe; } + u8 GetSpl() { return mSpl; } + u8 GetMtrl() { return mMtrl; } + u8 GetHitMark() { return mHitMark; } + void SetRVec(cXyz& vec) { mRVec = vec; } + void SetHitPos(cXyz& pos) { mHitPos = pos; } + + // private: + /* 0x1C */ u8 mSe; + /* 0x1D */ u8 mMtrl; + /* 0x1E */ u8 mHitMark; + /* 0x1F */ u8 mSpl; + /* 0x20 */ cXyz mHitPos; + /* 0x2C */ cXyz mVec; + /* 0x38 */ cXyz mRVec; +}; // Size = 0x44 + +// Defense (Tg) Collider +class dCcD_GObjTg : public dCcD_GAtTgCoCommonBase { +public: + void Set(dCcD_SrcGObjTg const&); + virtual ~dCcD_GObjTg() {} + void SetSe(u8 se) { mSe = se; } + void SetVec(cXyz& vec) { mVec = vec; } + cXyz& GetVec() { return mVec; } + void SetShieldFrontRangeYAngle(s16* angle) { mShieldFrontRangeYAngle = angle; } + void SetMtrl(u8 mtrl) { mMtrl = mtrl; } + u8 GetMtrl() { return mMtrl; } + void SetHitMark(CcG_Tg_HitMark mark) { mHitMark = mark; } + s16* GetShieldFrontRangeYAngle() { return mShieldFrontRangeYAngle; } + u8 GetSpl() { return mSpl; } + u8 GetHitMark() { return mHitMark; } + void SetRVec(cXyz& vec) { mRVec = vec; } + cXyz* GetVecP() { return &mVec; } + void SetHitPos(cXyz& pos) { mHitPos = pos; } + +private: + /* 0x1C */ u8 mSe; + /* 0x1D */ u8 mMtrl; + /* 0x1E */ u8 mHitMark; + /* 0x1F */ u8 mSpl; + /* 0x20 */ cXyz mVec; + /* 0x2C */ cXyz mRVec; + /* 0x38 */ cXyz mHitPos; + /* 0x44 */ s16* mShieldFrontRangeYAngle; +}; // Size = 0x48 + +// Correction (Co) Collider +class dCcD_GObjCo : public dCcD_GAtTgCoCommonBase { +public: + virtual ~dCcD_GObjCo() {} + void Set(dCcD_SrcGObjCo const& pSrc) { dCcD_GAtTgCoCommonBase::Set(pSrc.mBase); } +}; // Size = 0x1C ? + +// Object Info +class dCcD_GObjInf : public cCcD_GObjInf { +public: + dCcD_GObjInf(); + virtual ~dCcD_GObjInf(); + virtual cCcD_GObjInf* GetGObjInf(); + virtual void ClrAtHit(); + u32 ChkAtHit(); + void ResetAtHit(); + cCcD_Obj* GetAtHitObj(); + cCcD_GObjInf* GetAtHitGObj(); + u8 ChkAtNoGuard(); + virtual void ClrTgHit(); + u32 ChkTgHit(); + void ResetTgHit(); + cCcD_Obj* GetTgHitObj(); + dCcD_GObjInf* GetTgHitGObj(); + u8 GetTgHitObjSe(); + virtual void ClrCoHit(); + u32 ChkCoHit(); + void ResetCoHit(); + cCcD_Obj* GetCoHitObj(); + void Set(dCcD_SrcGObjInf const&); + + fopAc_ac_c* GetCoHitAc() { return mGObjCo.GetAc(); } + + void SetAtVec(cXyz& vec) { mGObjAt.SetVec(vec); } + void SetTgVec(cXyz& vec) { mGObjTg.SetVec(vec); } + bool ChkAtNoMass() const { return mGObjAt.ChkSPrm(8); } + void OnAtNoHitMark() { mGObjAt.OnSPrm(2); } + void OffAtNoHitMark() { mGObjAt.OffSPrm(2); } + void OnTgNoHitMark() { mGObjTg.OnSPrm(4); } + void OffTgNoHitMark() { mGObjTg.OffSPrm(4); } + void OnAtNoConHit() { mGObjAt.OnSPrm(1); } + void OffAtNoConHit() { mGObjAt.OffSPrm(1); } + void OnTgNoConHit() { mGObjTg.OnSPrm(2); } + void SetAtHitMark(u8 mark) { mGObjAt.SetHitMark(mark); } + void SetAtSe(u8 se) { mGObjAt.SetSe(se); } + void SetTgSe(u8 se) { mGObjTg.SetSe(se); } + void SetAtMtrl(u8 mtrl) { mGObjAt.SetMtrl(mtrl); } + void SetTgMtrl(u8 mtrl) { mGObjTg.SetMtrl(mtrl); } + fopAc_ac_c* GetAtHitAc() { return mGObjAt.GetAc(); } + bool ChkAtShieldHit() { return mGObjAt.ChkRPrm(1); } + cXyz* GetAtVecP() { return mGObjAt.GetVecP(); } + cXyz* GetTgVecP() { return mGObjTg.GetVecP(); } + void SetAtSpl(dCcG_At_Spl spl) { mGObjAt.SetAtSpl(spl); } + void SetAtHitCallback(dCcD_HitCallback callback) { mGObjAt.SetHitCallback(callback); } + void SetTgHitCallback(dCcD_HitCallback callback) { mGObjTg.SetHitCallback(callback); } + void SetCoHitCallback(dCcD_HitCallback callback) { mGObjCo.SetHitCallback(callback); } + u8 GetAtSe() { return mGObjAt.GetSe(); } + dCcG_At_Spl GetAtSpl() { return (dCcG_At_Spl)mGObjAt.GetSpl(); } + u8 GetAtMtrl() { return mGObjAt.GetMtrl(); } + u8 GetTgMtrl() { return mGObjTg.GetMtrl(); } + fopAc_ac_c* GetTgHitAc() { return mGObjTg.GetAc(); } + void SetTgShieldFrontRangeYAngle(s16* angle) { mGObjTg.SetShieldFrontRangeYAngle(angle); } + void OffTgWolfSpNoDamage() { mGObjTg.OffSPrm(0x800); } + void OnTgWolfSpNoDamage() { mGObjTg.OnSPrm(0x800); } + void SetTgHitMark(CcG_Tg_HitMark mark) { mGObjTg.SetHitMark(mark); } + void OnTgSpShield() { mGObjTg.OnSPrm(0x40); } + void OffTgSpShield() { mGObjTg.OffSPrm(0x40); } + void OnTgShield() { mGObjTg.OnSPrm(0x1); } + void OffTgShield() { mGObjTg.OffSPrm(0x1); } + void OnTgShieldFrontRange() { mGObjTg.OnSPrm(0x8); } + void OffTgShieldFrontRange() { mGObjTg.OffSPrm(0x8); } + bool ChkTgIronBallRebound() { return mGObjTg.ChkSPrm(0x100); } + s16* GetTgShieldFrontRangeYAngle() { return mGObjTg.GetShieldFrontRangeYAngle(); } + bool ChkTgShield() { return mGObjTg.ChkSPrm(1); } + bool ChkTgSpShield() { return mGObjTg.ChkSPrm(0x40); } + bool ChkTgSmallShield() { return mGObjTg.ChkSPrm(0x10); } + bool ChkTgShieldFrontRange() { return mGObjTg.ChkSPrm(8); } + bool ChkAtNoConHit() { return mGObjAt.ChkSPrm(1); } + bool ChkAtStopNoConHit() { return mGObjAt.ChkSPrm(0x4); } + bool ChkTgNoConHit() { return mGObjTg.ChkSPrm(2); } + bool ChkTgStopNoConHit() { return mGObjTg.ChkSPrm(0x2000); } + bool ChkCoNoCamHit() { return mGObjCo.ChkSPrm(2); } + dCcD_HitCallback GetCoHitCallback() { return mGObjCo.GetHitCallback(); } + dCcD_HitCallback GetAtHitCallback() { return mGObjAt.GetHitCallback(); } + dCcD_HitCallback GetTgHitCallback() { return mGObjTg.GetHitCallback(); } + void SetCoHitApid(unsigned int apid) { mGObjCo.SetHitApid(apid); } + void SetAtHitApid(unsigned int apid) { mGObjAt.SetHitApid(apid); } + void SetTgHitApid(unsigned int apid) { mGObjTg.SetHitApid(apid); } + void OnCoHitNoActor() { mGObjCo.OnRPrm(1); } + void OffCoHitNoActor() { mGObjCo.OffRPrm(1); } + void OnAtHitNoActor() { mGObjAt.OnRPrm(2); } + void OffAtHitNoActor() { mGObjAt.OffRPrm(2); } + void OnTgHitNoActor() { mGObjTg.OnRPrm(1); } + void OffTgHitNoActor() { mGObjTg.OffRPrm(1); } + bool ChkCoHitNoActor() const { return mGObjCo.ChkRPrm(1); } + bool ChkAtHitNoActor() const { return mGObjAt.ChkRPrm(2); } + bool ChkTgHitNoActor() const { return mGObjTg.ChkRPrm(1); } + bool ChkTgWolfSpNoDamage() { return mGObjTg.ChkSPrm(0x800); } + bool ChkAtNoHitMark() { return mGObjAt.ChkSPrm(2); } + bool ChkTgNoHitMark() { return mGObjTg.ChkSPrm(4); } + bool ChkTgHookShotNoHitMark() { return mGObjTg.ChkSPrm(0x400); } + bool ChkTgArrowNoHitMark() { return mGObjTg.ChkSPrm(0x1000); } + dCcG_Tg_Spl GetTgSpl() { return (dCcG_Tg_Spl)mGObjTg.GetSpl(); } + int GetTgHitMark() { return mGObjTg.GetHitMark(); } + int GetAtHitMark() { return mGObjAt.GetHitMark(); } + bool ChkAtEffCounter() { return mGObjAt.ChkEffCounter(); } + bool ChkTgEffCounter() { return mGObjTg.ChkEffCounter(); } + void ClrAtEffCounter() { mGObjAt.ClrEffCounter(); } + void ClrTgEffCounter() { mGObjTg.ClrEffCounter(); } + void ClrCoEffCounter() { mGObjCo.ClrEffCounter(); } + void SetAtEffCounterTimer() { mGObjAt.SetEffCounterTimer(); } + void SetTgEffCounterTimer() { mGObjTg.SetEffCounterTimer(); } + void SubtractAtEffCounter() { mGObjAt.SubtractEffCounter(); } + void SubtractTgEffCounter() { mGObjTg.SubtractEffCounter(); } + void SubtractCoEffCounter() { mGObjCo.SubtractEffCounter(); } + void OnTgShieldHit() { mGObjTg.OnRPrm(2); } + void OffTgShieldHit() { mGObjTg.OffRPrm(2); } + void OnAtShieldHit() { mGObjAt.OnRPrm(1); } + void OffAtShieldHit() { mGObjAt.OffRPrm(1); } + void OffTgMagneHit() { mGObjTg.OffRPrm(4); } + void SetTgRVec(cXyz& vec) { mGObjTg.SetRVec(vec); } + void SetAtRVec(cXyz& vec) { mGObjAt.SetRVec(vec); } + void SetTgHitPos(cXyz& pos) { mGObjTg.SetHitPos(pos); } + void SetAtHitPos(cXyz& pos) { mGObjAt.SetHitPos(pos); } + +protected: + /* 0x050 */ dCcD_GObjAt mGObjAt; + /* 0x094 */ dCcD_GObjTg mGObjTg; + /* 0x0DC */ dCcD_GObjCo mGObjCo; +}; // Size = 0xF8 + +STATIC_ASSERT(sizeof(dCcD_GObjInf) == 0xF8); + +// Cylinder +class dCcD_Cyl : public dCcD_GObjInf, public cCcD_CylAttr { +public: + void Set(dCcD_SrcCyl const&); + cCcD_ShapeAttr* GetShapeAttr(); + void StartCAt(cXyz&); + void MoveCAt(cXyz&); + void MoveCTg(cXyz&); + virtual ~dCcD_Cyl() {} + dCcD_Cyl() {} +}; // Size = 0x130 + +// Sphere +class dCcD_Sph : public dCcD_GObjInf, public cCcD_SphAttr { +public: + dCcD_Sph() {} + void Set(dCcD_SrcSph const&); + void StartCAt(cXyz&); + void MoveCAt(cXyz&); + virtual cCcD_ShapeAttr* GetShapeAttr(); + virtual ~dCcD_Sph() {} +}; // Size = 0x12C + +// Capsule +class dCcD_Cps : public dCcD_GObjInf, public cCcD_CpsAttr { +public: + void Set(dCcD_SrcCps const&); + cCcD_ShapeAttr* GetShapeAttr(); + void CalcAtVec(); + void CalcTgVec(); + virtual ~dCcD_Cps() {} + dCcD_Cps() {} +}; // Size = 0x138 + +// Triangle +class dCcD_Tri : public dCcD_GObjInf, public cCcD_TriAttr { +public: + void Set(dCcD_SrcTri const&); + cCcD_ShapeAttr* GetShapeAttr(); + virtual ~dCcD_Tri() {} + dCcD_Tri() {} +}; + +dCcD_GObjInf* dCcD_GetGObjInf(cCcD_Obj* param_0); + +#endif /* D_CC_D_CC_D_H */ \ No newline at end of file diff --git a/include/d/d_com_inf_game.h b/include/d/d_com_inf_game.h index ca174f687..e85ad0665 100644 --- a/include/d/d_com_inf_game.h +++ b/include/d/d_com_inf_game.h @@ -314,6 +314,8 @@ public: /* 0x1D1C1 */ u8 field_0x1d1c1; }; +STATIC_ASSERT(sizeof(dComIfG_inf_c) == 0x1D1C8); + extern dComIfG_inf_c g_dComIfG_gameInfo; /** diff --git a/include/d/d_drawlist.h b/include/d/d_drawlist.h index c9187c272..24aaeba5b 100644 --- a/include/d/d_drawlist.h +++ b/include/d/d_drawlist.h @@ -152,6 +152,17 @@ private: STATIC_ASSERT(sizeof(dDlst_shadowControl_c) == 0x15E28); +class dDlst_mirrorPacket : public J3DPacket { +public: + /* 0x0010 */ u8 field_0x0010[0x0040 - 0x0010]; + /* 0x0040 */ Mtx mPosMtx; + /* 0x0070 */ u8 field_0x0070[0x0080 - 0x0070]; + /* 0x0080 */ Mtx mTexMtx; + /* 0x00B0 */ dDlst_shadowRealPoly_c mShadowPoly; + /* 0x24B8 */ GXTexObj mTexObj; + /* 0x24D8 */ u8 mAlpha; +}; + struct view_port_class; struct view_class; struct camera_class; diff --git a/include/m_Do/m_Do_ext.h b/include/m_Do/m_Do_ext.h index d0e9ca84d..f12c42bdf 100644 --- a/include/m_Do/m_Do_ext.h +++ b/include/m_Do/m_Do_ext.h @@ -70,6 +70,42 @@ private: STATIC_ASSERT(sizeof(mDoExt_btkAnm) == 0x14); +class J3DTevColorAnm; +class J3DTevKColorAnm; +class mDoExt_brkAnm : public mDoExt_baseAnm { +public: + mDoExt_brkAnm() { mpAnm = 0; } + /* 8000D70C */ int init(J3DMaterialTable* i_matTable, J3DAnmTevRegKey* i_brk, int i_anmPlay, + int i_attribute, f32 i_rate, s16 i_start, s16 param_6); + /* 8000D7A8 */ void entry(J3DMaterialTable* i_matTable, f32 i_frame); + + void entry(J3DModelData* i_modelData) { entry(i_modelData, getFrame()); } + void entry(J3DModelData* i_modelData, f32 i_frame) { + entry(&i_modelData->getMaterialTable(), i_frame); + } + + int init(J3DModelData* i_modelData, J3DAnmTevRegKey* i_brk, int i_anmPlay, int i_attribute, + f32 i_rate, s16 i_start, s16 param_6) { + return init(&i_modelData->getMaterialTable(), i_brk, i_anmPlay, i_attribute, i_rate, + i_start, param_6); + } + + int remove(J3DModelData* i_modelData) { return i_modelData->removeTevRegAnimator(mpAnm); } + void entryFrame() { entryFrame(getFrame()); } + void entryFrame(f32 frame) { mpAnm->setFrame(frame); } + + J3DAnmTevRegKey* getBrkAnm() const { return mpAnm; } + +private: + /* 0x08 */ J3DAnmTevRegKey* mpAnm; + /* 0x0C */ J3DTevColorAnm* mpCRegAnm; + /* 0x10 */ J3DTevKColorAnm* mpKRegAnm; + /* 0x14 */ u16 mCRegUpdateMaterialNum; + /* 0x16 */ u16 mKRegUpdateMaterialNum; +}; // Size: 0x18 + +STATIC_ASSERT(sizeof(mDoExt_brkAnm) == 0x18); + class mDoExt_bckAnm : public mDoExt_baseAnm { public: mDoExt_bckAnm() { mpMtxCalc = NULL; } @@ -97,6 +133,97 @@ private: STATIC_ASSERT(sizeof(mDoExt_bckAnm) == 0x10); +class mDoExt_btpAnm : public mDoExt_baseAnm { +public: + mDoExt_btpAnm() { mpAnm = NULL; } + /* 8000D54C */ int init(J3DMaterialTable* i_matTable, J3DAnmTexPattern* i_btk, int i_anmPlay, + int i_attribute, f32 i_rate, s16 i_start, s16 param_6); + /* 8000D5E8 */ void entry(J3DMaterialTable* i_matTable, s16 i_frame); + + void entry(J3DModelData* i_modelData) { entry(i_modelData, getFrame()); } + void entry(J3DModelData* i_modelData, s16 i_frame) { + entry(&i_modelData->getMaterialTable(), i_frame); + } + + int init(J3DModelData* i_modelData, J3DAnmTexPattern* i_btk, int i_anmPlay, int i_attribute, + f32 i_rate, s16 i_start, s16 param_6) { + return init(&i_modelData->getMaterialTable(), i_btk, i_anmPlay, i_attribute, i_rate, + i_start, param_6); + } + + int remove(J3DModelData* i_modelData) { return i_modelData->removeTexNoAnimator(mpAnm); } + +private: + /* 0x14 */ J3DAnmTexPattern* mpAnm; +}; + +class mDoExt_blkAnm : public mDoExt_baseAnm { +public: + /* 8000DA08 */ int init(J3DDeformData* i_deformData, J3DAnmCluster* i_blk, int i_anmPlay, + int i_attribute, f32 i_rate, s16 i_start, s16 param_6); + + J3DAnmCluster* getBlkAnm() { return mpAnm; } + +private: + /* 0x14 */ J3DAnmCluster* mpAnm; +}; + +class mDoExt_AnmRatioPack { +public: + /* 80140DF0 */ ~mDoExt_AnmRatioPack(); + /* 80140E2C */ mDoExt_AnmRatioPack(); + + void setRatio(f32 ratio) { mRatio = ratio; } + f32 getRatio() { return mRatio; } + J3DAnmTransform* getAnmTransform() { return mAnmTransform; } + void setAnmTransform(J3DAnmTransform* anm) { mAnmTransform = anm; } + +private: + /* 0x0 */ f32 mRatio; + /* 0x4 */ J3DAnmTransform* mAnmTransform; +}; // Size: 0x8 + +class mDoExt_MtxCalcOldFrame { +public: + /* 8000F848 */ void initOldFrameMorf(f32, u16, u16); + /* 8000F8CC */ void decOldFrameMorfCounter(); + + f32 getOldFrameRate() { return mOldFrameRate; } + J3DTransformInfo* getOldFrameTransInfo(int i) { return &mOldFrameTransInfo[i]; } + u16 getOldFrameStartJoint() { return mOldFrameStartJoint; } + Quaternion* getOldFrameQuaternion(int i_no) { return &mOldFrameQuaternion[i_no]; } + +private: + /* 0x00 */ bool mOldFrameFlg; + /* 0x04 */ f32 mOldFrameMorfCounter; + /* 0x08 */ f32 field_0x8; + /* 0x0C */ f32 mOldFrameRate; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ u16 mOldFrameStartJoint; + /* 0x1A */ u16 mOldFrameEndJoint; + /* 0x1C */ J3DTransformInfo* mOldFrameTransInfo; + /* 0x20 */ Quaternion* mOldFrameQuaternion; +}; // Size: 0x24 + +struct mDoExt_MtxCalcAnmBlendTblOld + : public J3DMtxCalcNoAnm { + /* 80014EB0 */ virtual ~mDoExt_MtxCalcAnmBlendTblOld(); + /* 8000F4B0 */ virtual void calc(); + + /* 0x4 */ int mNum; + /* 0x8 */ mDoExt_AnmRatioPack* mAnmRatio; +}; // Size: 0xC + +struct mDoExt_MtxCalcAnmBlendTbl : public mDoExt_MtxCalcAnmBlendTblOld { + /* 800D00BC */ J3DAnmTransform* getAnm(int); + + /* 80014F3C */ virtual ~mDoExt_MtxCalcAnmBlendTbl(); + /* 8000F26C */ virtual void calc(); + + /* 0xC */ mDoExt_MtxCalcOldFrame* mOldFrame; +}; + class mDoExt_McaMorfCallBack1_c { public: virtual void execute(u16, J3DTransformInfo*) = 0;