From 227cf2353acb8dbea8b765a34d5aad9a68373d44 Mon Sep 17 00:00:00 2001 From: TakaRikka <38417346+TakaRikka@users.noreply.github.com> Date: Mon, 30 Jun 2025 15:17:50 -0700 Subject: [PATCH] some more wii tests/improvements (#2512) * some more wii tests/improvements * merge Z2AudioCS changes --- configure.py | 6 +- include/Z2AudioCSD/Z2AudioCS.h | 11 - include/Z2AudioLib/Z2AudioCS.h | 22 + include/d/actor/d_a_alink.h | 3 + include/d/d_home_button.h | 18 +- include/m_Do/m_Do_graphic.h | 78 +++- include/m_Do/m_Re_controller_pad.h | 177 +++++++- include/revolution/hbm.h | 72 ++-- include/revolution/kpad.h | 68 ++++ include/revolution/mtx.h | 383 ++++++++++++++++++ include/revolution/wpad.h | 61 +++ .../SComponent/c_API_controller_pad.cpp | 143 +++++++ src/Z2AudioLib/Z2LinkMgr.cpp | 2 +- src/d/actor/d_a_alink_demo.inc | 17 +- src/d/d_home_button.cpp | 212 +++++++++- src/m_Do/m_Re_controller_pad.cpp | 350 ++++++++++++++++ 16 files changed, 1561 insertions(+), 62 deletions(-) delete mode 100644 include/Z2AudioCSD/Z2AudioCS.h create mode 100644 include/Z2AudioLib/Z2AudioCS.h create mode 100644 include/revolution/kpad.h create mode 100644 include/revolution/mtx.h create mode 100644 include/revolution/wpad.h diff --git a/configure.py b/configure.py index 68cb465f34..3e6f9cf206 100755 --- a/configure.py +++ b/configure.py @@ -246,7 +246,7 @@ cflags_base = [ if config.version == "ShieldD": cflags_base.extend(["-O0", "-inline off", "-RTTI on", "-str reuse", "-enc SJIS", "-DDEBUG=1"]) elif config.version == "RZDE01_00": - cflags_base.extend(["-O4,p", "-inline auto", "-RTTI on", "-str reuse", "-enc SJIS"]) + cflags_base.extend(["-O4,p", "-inline auto", "-ipa file", "-RTTI on", "-str reuse", "-enc SJIS"]) else: cflags_base.extend(["-O4,p", "-inline auto", "-RTTI off", "-str reuse", "-multibyte"]) @@ -336,7 +336,7 @@ cflags_framework = [ if config.version != "ShieldD": if config.version == "RZDE01_00": # TODO: whats the correct inlining flag? deferred looks better in some places, others not. something else wrong? - cflags_framework.extend(["-inline on", "-O4,s", "-sym on"]) + cflags_framework.extend(["-inline noauto", "-O4,s", "-sym on"]) else: cflags_framework.extend(["-inline noauto", "-O3,s", "-sym on", "-str reuse,pool,readonly"]) @@ -356,7 +356,7 @@ def MWVersion(cfg_version: str | None) -> str: case "GZ2J01": return "GC/2.7" case "RZDE01_00": - return "GC/3.0a3" + return "GC/3.0a5.2t" case "ShieldD": return "Wii/1.0" case _: diff --git a/include/Z2AudioCSD/Z2AudioCS.h b/include/Z2AudioCSD/Z2AudioCS.h deleted file mode 100644 index b5b7dac444..0000000000 --- a/include/Z2AudioCSD/Z2AudioCS.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef Z2AUDIOCS_H -#define Z2AUDIOCS_H - -#include "global.h" - -class Z2AudioCS { -public: - static int startLevel(s32 param_1, s32 param_2); -}; - -#endif diff --git a/include/Z2AudioLib/Z2AudioCS.h b/include/Z2AudioLib/Z2AudioCS.h new file mode 100644 index 0000000000..a61304879a --- /dev/null +++ b/include/Z2AudioLib/Z2AudioCS.h @@ -0,0 +1,22 @@ +#ifndef Z2AUDIOCS_H +#define Z2AUDIOCS_H + +#include + +class JKRHeap; +class JKRArchive; + +class Z2AudioCS { +public: + void newSpkSoundMemPool(); + int init(JKRHeap*, JKRArchive*, s32, s32); + void update(); + static void connect(s32); + static void disconnect(s32); + static void extensionProcess(s32, s32); + u32 getHandleSoundID(s32); + void start(s32, s32); + static void startLevel(s32, s32); +}; + +#endif /* Z2AUDIOCS_H */ diff --git a/include/d/actor/d_a_alink.h b/include/d/actor/d_a_alink.h index d929ca105f..5680558bf4 100644 --- a/include/d/actor/d_a_alink.h +++ b/include/d/actor/d_a_alink.h @@ -3907,6 +3907,9 @@ public: /* 0x02018 */ daPy_frameCtrl_c mUpperFrameCtrl[3]; /* 0x02060 */ mDoExt_MtxCalcOldFrame* field_0x2060; /* 0x02064 */ daAlink_sight_c mSight; + #if PLATFORM_WII + u8 unk_0x20f0[4]; + #endif /* 0x020F0 */ daPy_anmHeap_c mAnmHeap3; /* 0x02104 */ daPy_anmHeap_c mAnmHeap4; /* 0x02118 */ daPy_anmHeap_c mFaceBtpHeap; diff --git a/include/d/d_home_button.h b/include/d/d_home_button.h index ebb40dbfa7..b28604a353 100644 --- a/include/d/d_home_button.h +++ b/include/d/d_home_button.h @@ -6,17 +6,29 @@ class dHomeButton_c { public: + dHomeButton_c() { + field_0x7c = 0; + } + void create_(int, void*); int execute_(); void initHomeButtonInfo(int, void*); void initCursorPos(); void calcCursorPos(); void onReset(); - void create(int, void*); - int execute(); - void drawCapture(u8, void (*)(J2DOrthoGraph&, void*), void*); + + static void create(int, void*); + static int execute(); + static void drawCapture(u8, void (*)(J2DOrthoGraph&, void*), void*); + + static dHomeButton_c* m_myObj; + static u8 lbl_8053A724; + static u8 lbl_8053A725; /* 0x00 */ HBMDataInfo m_info; + /* 0x38 */ HBMControllerData m_controllerData; + /* 0x78 */ u32 field_0x78; + /* 0x7C */ u8 field_0x7c; }; #endif /* D_HOME_BUTTON_H */ diff --git a/include/m_Do/m_Do_graphic.h b/include/m_Do/m_Do_graphic.h index ad330df010..1440a78114 100644 --- a/include/m_Do/m_Do_graphic.h +++ b/include/m_Do/m_Do_graphic.h @@ -3,6 +3,7 @@ #include "JSystem/JFramework/JFWDisplay.h" #include "dolphin/mtx.h" +#include "global.h" int mDoGph_Create(); void mDoGph_drawFilterQuad(s8 param_0, s8 param_1); @@ -74,14 +75,58 @@ public: static BOOL isAutoForcus() { return data_80450BE7; } static void setTickRate(u32 rate) { JFWDisplay::getManager()->setTickRate(rate); } static void waitBlanking(int wait) { JFWDisplay::getManager()->waitBlanking(wait); } - static f32 getWidthF() { return 608.0f; } - static f32 getHeightF() { return 448.0f; } + + static f32 getWidthF() { + #if PLATFORM_WII || PLATFORM_SHIELD + return m_widthF; + #else + return 608.0f; + #endif + } + + static f32 getHeightF() { + #if PLATFORM_WII || PLATFORM_SHIELD + return m_heightF; + #else + return 448.0f; + #endif + } + static f32 getWidth() { return 608.0f; } static f32 getHeight() { return 448.0f; } - static f32 getMinYF() { return 0.0f; } - static f32 getMinXF() { return 0.0f; } - static f32 getMaxYF() { return 448.0f; } - static f32 getMaxXF() { return 608.0f; } + + static f32 getMinYF() { + #if PLATFORM_WII || PLATFORM_SHIELD + return m_minYF; + #else + return 0.0f; + #endif + } + + static f32 getMinXF() { + #if PLATFORM_WII || PLATFORM_SHIELD + return m_minXF; + #else + return 0.0f; + #endif + } + + static f32 getMaxYF() { + #if PLATFORM_WII || PLATFORM_SHIELD + return m_maxYF; + #else + return 448.0f; + #endif + } + + static f32 getMaxXF() { + #if PLATFORM_WII || PLATFORM_SHIELD + return m_maxXF; + #else + return 608.0f; + #endif + } + static f32 getAspect() { return 1.3571428f; } static int getMinY() { return 0; } static int getMinX() { return 0; } @@ -105,7 +150,13 @@ public: static void setFrameRate(u16 i_rate) { JFWDisplay::getManager()->setFrameRate(i_rate); } // NONMATCHING - Need to define all mDoGph_gInf_c shieldD members - static u8 isWide() { return false; } + static u8 isWide() { + #if PLATFORM_WII || PLATFORM_SHIELD + return mWide == TRUE; + #else + return false; + #endif + } static GXTexObj mFrameBufferTexObj; static GXTexObj mZbufferTexObj; @@ -123,6 +174,19 @@ public: static bool mBlureFlag; static u8 mBlureRate; static u8 mFade; + + #if PLATFORM_WII || PLATFORM_SHIELD + static u8 mWide; + static ResTIMG* m_fullFrameBufferTimg; + static void* m_fullFrameBufferTex; + static GXTexObj m_fullFrameBufferTexObj; + static f32 m_minXF; + static f32 m_minYF; + static f32 m_maxXF; + static f32 m_maxYF; + static f32 m_heightF; + static f32 m_widthF; + #endif }; #endif /* M_DO_M_DO_GRAPHIC_H */ diff --git a/include/m_Do/m_Re_controller_pad.h b/include/m_Do/m_Re_controller_pad.h index c388f95ddc..b7470a1b19 100644 --- a/include/m_Do/m_Re_controller_pad.h +++ b/include/m_Do/m_Re_controller_pad.h @@ -1,13 +1,186 @@ #ifndef M_RE_CONTROLLER_PAD_H #define M_RE_CONTROLLER_PAD_H -#include +#include +#include class mReCPd { public: struct Pad { - struct Acc {}; + struct Acc { + void clean(); + void changeStts(u32, bool); + void calcSwingVec(); + void calcSttsRem(); + void calcSttsFs(); + + /* 0x000 */ Vec field_0x0[120]; + /* 0x5A0 */ Vec field_0x5a0[120]; + /* 0xB40 */ int field_0xb40; + /* 0xB44 */ int m_swing; + /* 0xB48 */ Vec2 m_swingVec; + /* 0xB50 */ u8 field_0xb50; + /* 0xB51 */ u8 field_0xb51; + /* 0xB54 */ f32 field_0xb54; + /* 0xB58 */ u8 field_0xB58[0xB68 - 0xB58]; + /* 0xB68 */ Mtx field_0xb68; + /* 0xB98 */ f32 field_0xb98; + /* 0xB9C */ int field_0xb9c; + /* 0xBA0 */ f32 field_0xba0; + /* 0xBA4 */ f32 field_0xba4; + /* 0xBA8 */ u8 field_0xBA8[0xBAC - 0xBA8]; + /* 0xBAC */ int field_0xbac; + /* 0xBB0 */ f32 field_0xbb0; + /* 0xBB4 */ f32 field_0xbb4; + /* 0xBB8 */ u8 field_0xBB8[0xBBC - 0xBB8]; + /* 0xBBC */ int field_0xbbc; + /* 0xBC0 */ int field_0xbc0; + }; + + void clean(); + void cleanOneTime(); + void copyRemAcc(); + void copyFSAcc(); + void cleanTrig(); + void cleanHold(); + void cleanRelease(); + void clearUpDown(); + void calcDpdBox(Vec2*, Vec2*, f32, f32); + void calcDpdOld(); + void calcDpd2DPos(); + void calcDpdRatioPos(); + void calcDpdPlayCirPos(); + void calcDpdPlayBoxPos(); + + /* 0x0000 */ u32 field_0x0; + /* 0x0004 */ KPADStatus field_0x4[10]; + /* 0x0554 */ int field_0x554; + /* 0x0558 */ KPADStatus field_0x558; + /* 0x05E0 */ Acc m_remAcc; + /* 0x11A4 */ Acc m_FSAcc; + /* 0x1D68 */ f32 m_stick3D; + /* 0x1D6C */ f32 field_0x1d6c; + /* 0x1D70 */ f32 m_stickValue; + /* 0x1D74 */ s16 m_stickAngle; + /* 0x1D76 */ s16 m_stick3DAngle; + /* 0x1D78 */ Vec2 field_0x1d78; + /* 0x1D80 */ Vec2 field_0x1d80; + /* 0x1D88 */ f32 field_0x1d88; + /* 0x1D8C */ f32 field_0x1d8c; + /* 0x1D90 */ f32 field_0x1d90; + /* 0x1D94 */ f32 field_0x1d94; + /* 0x1D98 */ f32 field_0x1d98; + /* 0x1D9C */ f32 field_0x1d9c; + /* 0x1DA0 */ f32 field_0x1da0; + /* 0x1DA4 */ f32 field_0x1da4; + /* 0x1DA8 */ Vec2 field_0x1da8; + /* 0x1DB0 */ Vec2 field_0x1db0; + /* 0x1DB8 */ f32 field_0x1db8; + /* 0x1DBC */ f32 field_0x1dbc; + /* 0x1DC0 */ f32 field_0x1dc0; + /* 0x1DC4 */ int field_0x1dc4; + /* 0x1DC8 */ int field_0x1dc8; + /* 0x1DCC */ int m_swingBlock; + /* 0x1DD0 */ int field_0x1dd0; + /* 0x1DD4 */ u8 field_0x1dd4; + /* 0x1DD8 */ int field_0x1dd8; + /* 0x1DDC */ u8 field_0x1ddc; + /* 0x1DDD */ u8 field_0x1ddd; + /* 0x1DE0 */ int field_0x1de0; + /* 0x1DE4 */ int field_0x1de4; + /* 0x1DE8 */ u8 field_0x1de8; + /* 0x1DEC */ int field_0x1dec; + /* 0x1DF0 */ u8 field_0x1df0; + /* 0x1DF4 */ int field_0x1df4; + /* 0x1DF8 */ u32 field_0x1df8; + /* 0x1DFC */ u32 field_0x1dfc; + /* 0x1E00 */ int field_0x1e00; + /* 0x1E04 */ u8 field_0x1e04; + /* 0x1E05 */ u8 field_0x1e05; }; + + struct motorWave_t { + u8* field_0x0; + u16 field_0x4; + u16 field_0x6; + u8 field_0x8; + }; + + static void enableDpd(u32); + static void disableDpd(u32); + static void onConnect(u32); + static void setExtensionCallback(); + static void onGetInfoAsync(u32); + static void create(); + static void startMoterWave(motorWave_t*, u8*, bool); + static void startMoterWave(int, u8*, bool); + static void stopMoterWave(motorWave_t*); + static void stopMoterWave(int); + static void updateMoterWave(); + static void stopMoter(); + static void getLowBat(u32); + static void setLowBat(u32, int); + static void onLowBatChk(u32); + static void procNoData(u32); + static void read(); + static void calibrateDist(int); + static void getDpd2DPos(u32); + static void getDpdRatioPos(u32); + static void getDpdRatioBoxPos(u32); + static void chkDpdOk(u32); + static void chkDpdValid(u32); + static void chkDpdPosIn(u32); + static void getKPADAcc(u32, Vec*, int); + static void getAngleXy(u32); + static void getAngleZy(u32); + static void getKPADAccValue(u32, int); + static void getKPADAccValueMax(u32); + static void getKPADAccSpeed(u32, int); + static void getKPADAccSpeedMax(u32); + static void getKPADFsAccValue(u32, int); + static void getKPADFsAccValueMax(u32); + static s16 getFSStickAngle3DRev(u32); + static void calcUnderVec(Pad::Acc*, f32); + + static u32 getHoldB(u32); + static u32 getHoldMinus(u32); + static u32 getHoldPlus(u32); + static u32 getHoldZ1(u32); + static u32 getTrigB(u32); + static u32 getTrigMinus(u32); + static u32 getTrigHome(u32); + static u32 getTrigPlus(u32); + static u32 getTrigZ1(u32); + static u32 chkSwingBlock(u32); + static u32 getTrigSwing(u32); + static Vec2& getSwingVec(u32); + static u32 chkSimpleProbe(u32); + static BOOL chkDevTypeValid(u32); + static u32 getFSTrigSwing(u32); + + static void plusCalValue(); + static void minusCalValue(); + + // made up, copying concepts from m_Do_controller_pad + static WPADInfo& getPadInfo(u32 i_pad) { return m_pad_info[i_pad]; } + static Pad& getPad(u32 i_pad) { return m_pad[i_pad]; } + static u32 getTrig(u32 i_pad) { return getPad(i_pad).field_0x4[0].trig; } + static u32 getHold(u32 i_pad) { return getPad(i_pad).field_0x4[0].hold; } + + static u32 getHoldA(u32 i_pad) { return getHold(i_pad) & WPAD_BUTTON_A; } + static u32 getHoldRight(u32 i_pad) { return getHold(i_pad) & WPAD_BUTTON_RIGHT; } + static u32 getHoldLeft(u32 i_pad) { return getHold(i_pad) & WPAD_BUTTON_LEFT; } + static u32 getHoldUp(u32 i_pad) { return getHold(i_pad) & WPAD_BUTTON_UP; } + static u32 getTrigA(u32 i_pad) { return getTrig(i_pad) & WPAD_BUTTON_A; } + static u32 getTrigRight(u32 i_pad) { return getTrig(i_pad) & WPAD_BUTTON_RIGHT; } + static u32 getTrigLeft(u32 i_pad) { return getTrig(i_pad) & WPAD_BUTTON_LEFT; } + + static u32 getTrigUp(u32 i_pad) { return getTrig(i_pad) & WPAD_BUTTON_UP; } + static u32 getTrigStart(u32 i_pad) { return getTrig(i_pad) & WPAD_BUTTON_PLUS; } + + static WPADInfo m_pad_info[4]; + static Pad m_pad[4]; + static int m_cal_value; }; #endif /* M_RE_CONTROLLER_PAD_H */ diff --git a/include/revolution/hbm.h b/include/revolution/hbm.h index c6685bcd13..ac3a34b0bf 100644 --- a/include/revolution/hbm.h +++ b/include/revolution/hbm.h @@ -1,43 +1,69 @@ #ifndef _REVOLUTION_HBM_H_ #define _REVOLUTION_HBM_H_ -#include +#include #ifdef __cplusplus extern "C" { #endif +typedef enum HBMSelectBtnNum { + HBM_SELECT_NULL = -1, -// TODO: properly setup later + HBM_SELECT_HOMEBTN, + HBM_SELECT_BTN1, + HBM_SELECT_BTN2, + HBM_SELECT_BTN3, + HBM_SELECT_BTN4, -typedef struct Vec2 { - f32 x; // size 0x04, offset 0x00 - f32 y; // size 0x04, offset 0x04 -} Vec2; // size 0x08 + HBM_SELECT_MAX +} HBMSelectBtnNum; +// TODO: move this later typedef struct MEMAllocator MEMAllocator; typedef int HBMSoundCallback(int evt, int num); - typedef struct HBMDataInfo { - void *layoutBuf; // size 0x04, offset 0x00 - void *spkSeBuf; // size 0x04, offset 0x04 - void *msgBuf; // size 0x04, offset 0x08 - void *configBuf; // size 0x04, offset 0x0c - void *mem; // size 0x04, offset 0x10 - HBMSoundCallback *sound_callback; // size 0x04, offset 0x14 - int backFlag; // size 0x04, offset 0x18 - int region; // size 0x04, offset 0x1c - int cursor; // size 0x04, offset 0x20 - u32 memSize; // size 0x04, offset 0x24 - f32 frameDelta; // size 0x04, offset 0x28 - Vec2 adjust; // size 0x08, offset 0x2c - MEMAllocator *pAllocator; // size 0x04, offset 0x34 -} HBMDataInfo; // size 0x40 + /* 0x00 */ void* layoutBuf; + /* 0x04 */ void* spkSeBuf; + /* 0x08 */ void* msgBuf; + /* 0x0C */ void* configBuf; + /* 0x10 */ void* mem; + /* 0x14 */ HBMSoundCallback* sound_callback; + /* 0x18 */ int backFlag; + /* 0x1C */ int region; + /* 0x20 */ int cursor; + /* 0x24 */ u32 memSize; + /* 0x28 */ f32 frameDelta; + /* 0x2C */ Vec2 adjust; + /* 0x34 */ MEMAllocator* pAllocator; +} HBMDataInfo; // size 0x38 -void HBMCreate(const HBMDataInfo *pHBInfo); +typedef struct HBMKPadData { + KPADStatus* kpad; + Vec2 pos; + u32 use_devtype; +} HBMKPadData; // size 0x10 + +typedef struct HBMControllerData { + HBMKPadData wiiCon[WPAD_MAX_CONTROLLERS]; +} HBMControllerData; // size 0x40 + +void HBMCreate(const HBMDataInfo* pHBInfo); +void HBMDelete(void); +void HBMInit(void); +HBMSelectBtnNum HBMCalc(const HBMControllerData* pController); +void HBMDraw(void); +HBMSelectBtnNum HBMGetSelectBtnNum(void); +void HBMSetAdjustFlag(BOOL flag); +void HBMStartBlackOut(void); +BOOL HBMIsReassignedControllers(void); + +void HBMCreateSound(void* soundData, void* memBuf, u32 memSize); +void HBMDeleteSound(void); +void HBMUpdateSound(void); #ifdef __cplusplus } #endif -#endif // _REVOLUTION_HBM_H_ +#endif // _REVOLUTION_HBM_H_ diff --git a/include/revolution/kpad.h b/include/revolution/kpad.h new file mode 100644 index 0000000000..ed554ab3ad --- /dev/null +++ b/include/revolution/kpad.h @@ -0,0 +1,68 @@ +#ifndef _REVOLUTION_KPAD_H_ +#define _REVOLUTION_KPAD_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Vec2 { + f32 x, y; +} Vec2; + +typedef s32 KPADResult; + +typedef union KPADEXStatus { + struct { + Vec2 stick; + Vec acc; + f32 acc_value; + f32 acc_speed; + } fs; // size 0x1c + + struct { + u32 hold; + u32 trig; + u32 release; + Vec2 lstick; + Vec2 rstick; + f32 ltrigger; + f32 rtrigger; + } cl; // size 0x24 +} KPADEXStatus; + +typedef struct KPADStatus { + /* 0x00 */ u32 hold; + /* 0x04 */ u32 trig; + /* 0x08 */ u32 release; + /* 0x0C */ Vec acc; + /* 0x18 */ f32 acc_value; + /* 0x1C */ f32 acc_speed; + /* 0x20 */ Vec2 pos; + /* 0x28 */ Vec2 vec; + /* 0x30 */ f32 speed; + /* 0x34 */ Vec2 horizon; + /* 0x3C */ Vec2 hori_vec; + /* 0x44 */ f32 hori_speed; + /* 0x48 */ f32 dist; + /* 0x4C */ f32 dist_vec; + /* 0x50 */ f32 dist_speed; + /* 0x54 */ Vec2 acc_vertical; + /* 0x5C */ u8 dev_type; + /* 0x5D */ s8 wpad_err; + /* 0x5E */ s8 dpd_valid_fg; + /* 0x5F */ u8 data_format; + /* 0x60 */ KPADEXStatus ex_status; + /* 0x84 */ u8 __paddings__[4]; // ??? is this the compiler? +} KPADStatus; // size 0x88 + +void KPADEnableDPD(s32); +void KPADDisableDPD(s32); + +#ifdef __cplusplus +} +#endif + +#endif // _REVOLUTION_KPAD_H_ diff --git a/include/revolution/mtx.h b/include/revolution/mtx.h new file mode 100644 index 0000000000..91519664ae --- /dev/null +++ b/include/revolution/mtx.h @@ -0,0 +1,383 @@ +#ifndef _DOLPHIN_MTX_H_ +#define _DOLPHIN_MTX_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Vec { + f32 x, y, z; +} Vec, *VecPtr, Point3d, *Point3dPtr; + +typedef struct { + s16 x, y, z; +} S16Vec, *S16VecPtr; + +typedef struct { + f32 x, y, z, w; +} Quaternion, *QuaternionPtr, Qtrn, *QtrnPtr; + +typedef f32 Mtx[3][4]; +typedef f32 (*MtxPtr)[4]; + +typedef f32 Mtx44[4][4]; +typedef f32 (*Mtx44Ptr)[4]; + +typedef f32 ROMtx[4][3]; +typedef f32 (*ROMtxPtr)[4]; + +// do these belong in the sdk? +typedef f32 Mtx33[3][3]; +typedef f32 Mtx23[2][3]; +typedef f32 (*Mtx3P)[3]; +typedef f32 (*MtxP)[4]; +typedef const f32 (*CMtxP)[4]; +typedef f32 QuaternionP[4]; + +typedef struct { + u32 numMtx; + MtxPtr stackBase; + MtxPtr stackPtr; +} MTXStack; + +#define MTXDegToRad(d) (d * 0.01745329252f) +#define MTXRadToDeg(r) (r * 57.29577951f) + +// MTX +// C version +void C_MTXIdentity(Mtx m); +void C_MTXCopy(const Mtx src, Mtx dst); +void C_MTXConcat(const Mtx a, const Mtx b, Mtx ab); +void C_MTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count); +void C_MTXTranspose(const Mtx src, Mtx xPose); +u32 C_MTXInverse(const Mtx src, Mtx inv); +u32 C_MTXInvXpose(const Mtx src, Mtx invX); +void C_MTXRotRad(Mtx m, char axis, f32 rad); +void C_MTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA); +void C_MTXRotAxisRad(Mtx m, const Vec* axis, f32 rad); +void C_MTXTrans(Mtx m, f32 xT, f32 yT, f32 zT); +void C_MTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT); +void C_MTXScale(Mtx m, f32 xS, f32 yS, f32 zS); +void C_MTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS); +void C_MTXQuat(Mtx m, const Quaternion* q); +void C_MTXReflect(Mtx m, const Vec* p, const Vec* n); + +// PS version +void PSMTXIdentity(Mtx m); +void PSMTXCopy(const Mtx src, Mtx dst); +void PSMTXConcat(const Mtx a, const Mtx b, Mtx ab); +void PSMTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count); +void PSMTXTranspose(const Mtx src, Mtx xPose); +u32 PSMTXInverse(const Mtx src, Mtx inv); +u32 PSMTXInvXpose(const Mtx src, Mtx invX); +void PSMTXRotRad(Mtx m, char axis, f32 rad); +void PSMTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA); +void PSMTXRotAxisRad(Mtx m, const Vec* axis, f32 rad); +void PSMTXTrans(Mtx m, f32 xT, f32 yT, f32 zT); +void PSMTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT); +void PSMTXScale(Mtx m, f32 xS, f32 yS, f32 zS); +void PSMTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS); +void PSMTXQuat(Mtx m, const Quaternion* q); +void PSMTXReflect(Mtx m, const Vec* p, const Vec* n); + +#ifdef DEBUG +#define MTXIdentity C_MTXIdentity +#define MTXCopy C_MTXCopy +#define MTXConcat C_MTXConcat +#define MTXInverse C_MTXInverse +#define MTXTranspose C_MTXTranspose +#define MTXInverse C_MTXInverse +#define MTXInvXpose C_MTXInvXpose +#define MTXRotRad C_MTXRotRad +#define MTXRotTrig C_MTXRotTrig +#define MTXRotAxisRad C_MTXRotAxisRad +#define MTXTrans C_MTXTrans +#define MTXTransApply C_MTXTransApply +#define MTXScale C_MTXScale +#define MTXScaleApply C_MTXScaleApply +#define MTXQuat C_MTXQuat +#define MTXReflect C_MTXReflect +#else +#define MTXIdentity PSMTXIdentity +#define MTXCopy PSMTXCopy +#define MTXConcat PSMTXConcat +#define MTXInverse PSMTXInverse +#define MTXTranspose PSMTXTranspose +#define MTXInverse PSMTXInverse +#define MTXInvXpose PSMTXInvXpose +#define MTXRotRad PSMTXRotRad +#define MTXRotTrig PSMTXRotTrig +#define MTXRotAxisRad PSMTXRotAxisRad +#define MTXTrans PSMTXTrans +#define MTXTransApply PSMTXTransApply +#define MTXScale PSMTXScale +#define MTXScaleApply PSMTXScaleApply +#define MTXQuat PSMTXQuat +#define MTXReflect PSMTXReflect +#endif + +// C versions only +void C_MTXLookAt(Mtx m, const Point3d* camPos, const Vec* camUp, const Point3d* target); +void C_MTXLightFrustum(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 scaleS, f32 scaleT, f32 transS, f32 transT); +void C_MTXLightPerspective(Mtx m, f32 fovY, f32 aspect, f32 scaleS, f32 scaleT, f32 transS, f32 transT); +void C_MTXLightOrtho(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT, f32 transS, f32 transT); + +#define MTXLookAt C_MTXLookAt +#define MTXLightFrustum C_MTXLightFrustum +#define MTXLightPerspective C_MTXLightPerspective +#define MTXLightOrtho C_MTXLightOrtho + +// MTXVEC +// C versions +void C_MTXMultVec(const Mtx m, const Vec* src, Vec* dst); +void C_MTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); +void C_MTXMultVecSR(const Mtx m, const Vec* src, Vec* dst); +void C_MTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); + +// PS versions +void PSMTXMultVec(const Mtx m, const Vec* src, Vec* dst); +void PSMTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXMultVecSR(const Mtx m, const Vec* src, Vec* dst); +void PSMTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); + +#ifdef DEBUG +#define MTXMultVec C_MTXMultVec +#define MTXMultVecArray C_MTXMultVecArray +#define MTXMultVecSR C_MTXMultVecSR +#define MTXMultVecArraySR C_MTXMultVecArraySR +#else +#define MTXMultVec PSMTXMultVec +#define MTXMultVecArray PSMTXMultVecArray +#define MTXMultVecSR PSMTXMultVecSR +#define MTXMultVecArraySR PSMTXMultVecArraySR +#endif + +// MTX44 +// C versions +void C_MTX44Identity(Mtx44 m); +void C_MTX44Copy(const Mtx44 src, Mtx44 dst); +void C_MTX44Concat(const Mtx44 a, const Mtx44 b, Mtx44 ab); +void C_MTX44Transpose(const Mtx44 src, Mtx44 xPose); +void C_MTX44Trans(Mtx44 m, f32 xT, f32 yT, f32 zT); +void C_MTX44TransApply(const Mtx44 src, Mtx44 dst, f32 xT, f32 yT, f32 zT); +void C_MTX44Scale(Mtx44 m, f32 xS, f32 yS, f32 zS); +void C_MTX44ScaleApply(const Mtx44 src, Mtx44 dst, f32 xS, f32 yS, f32 zS); +void C_MTX44RotRad(Mtx44 m, char axis, f32 rad); +void C_MTX44RotTrig(Mtx44 m, char axis, f32 sinA, f32 cosA); +void C_MTX44RotAxisRad(Mtx44 m, const Vec* axis, f32 rad); + +// PS versions +void PSMTX44Identity(Mtx44 m); +void PSMTX44Copy(const Mtx44 src, Mtx44 dst); +void PSMTX44Concat(const Mtx44 a, const Mtx44 b, Mtx44 ab); +void PSMTX44Transpose(const Mtx44 src, Mtx44 xPose); +void PSMTX44Trans(Mtx44 m, f32 xT, f32 yT, f32 zT); +void PSMTX44TransApply(const Mtx44 src, Mtx44 dst, f32 xT, f32 yT, f32 zT); +void PSMTX44Scale(Mtx44 m, f32 xS, f32 yS, f32 zS); +void PSMTX44ScaleApply(const Mtx44 src, Mtx44 dst, f32 xS, f32 yS, f32 zS); +void PSMTX44RotRad(Mtx44 m, char axis, f32 rad); +void PSMTX44RotTrig(Mtx44 m, char axis, f32 sinA, f32 cosA); +void PSMTX44RotAxisRad(Mtx44 m, const Vec* axis, f32 rad); + +#ifdef DEBUG +#define MTX44Identity C_MTX44Identity +#define MTX44Copy C_MTX44Copy +#define MTX44Concat C_MTX44Concat +#define MTX44Transpose C_MTX44Transpose +#define MTX44Trans C_MTX44Trans +#define MTX44TransApply C_MTX44TransApply +#define MTX44Scale C_MTX44Scale +#define MTX44ScaleApply C_MTX44ScaleApply +#define MTX44RotRad C_MTX44RotRad +#define MTX44RotTrig C_MTX44RotTrig +#define MTX44RotAxisRad C_MTX44RotAxisRad +#else +#define MTX44Identity PSMTX44Identity +#define MTX44Copy PSMTX44Copy +#define MTX44Concat PSMTX44Concat +#define MTX44Transpose PSMTX44Transpose +#define MTX44Trans PSMTX44Trans +#define MTX44TransApply PSMTX44TransApply +#define MTX44Scale PSMTX44Scale +#define MTX44ScaleApply PSMTX44ScaleApply +#define MTX44RotRad PSMTX44RotRad +#define MTX44RotTrig PSMTX44RotTrig +#define MTX44RotAxisRad PSMTX44RotAxisRad +#endif + +// C versions only +void C_MTXFrustum(Mtx44 m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f); +void C_MTXPerspective(Mtx44 m, f32 fovY, f32 aspect, f32 n, f32 f); +void C_MTXOrtho(Mtx44 m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f); +u32 C_MTX44Inverse(const Mtx44 src, Mtx44 inv); + +#define MTXFrustum C_MTXFrustum +#define MTXPerspective C_MTXPerspective +#define MTXOrtho C_MTXOrtho +#define MTX44Inverse C_MTX44Inverse + +// MTX44VEC +// C versions +void C_MTX44MultVec(const Mtx44 m, const Vec* src, Vec* dst); +void C_MTX44MultVecArray(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); +void C_MTX44MultVecSR(const Mtx44 m, const Vec* src, Vec* dst); +void C_MTX44MultVecArraySR(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); + +// PS versions +void PSMTX44MultVec(const Mtx44 m, const Vec* src, Vec* dst); +void PSMTX44MultVecArray(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTX44MultVecSR(const Mtx44 m, const Vec* src, Vec* dst); +void PSMTX44MultVecArraySR(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); + +#ifdef DEBUG +#define MTX44MultVec C_MTX44MultVec +#define MTX44MultVecArray C_MTX44MultVecArray +#define MTX44MultVecSR C_MTX44MultVecSR +#define MTX44MultVecArraySR C_MTX44MultVecArraySR +#else +#define MTX44MultVec PSMTX44MultVec +#define MTX44MultVecArray PSMTX44MultVecArray +#define MTX44MultVecSR PSMTX44MultVecSR +#define MTX44MultVecArraySR PSMTX44MultVecArraySR +#endif + +// PSMTX +void PSMTXReorder(const Mtx src, ROMtx dest); +void PSMTXROMultVecArray(const ROMtx m, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXROSkin2VecArray(const ROMtx m0, const ROMtx m1, const f32* wtBase, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXROMultS16VecArray(const Mtx m, const S16Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXMultS16VecArray(const ROMtx* m, const S16Vec* srcBase, Vec* dstBase, u32 count); + +// MTXSTACK +void MTXInitStack(MTXStack* sPtr, u32 numMtx); +MtxPtr MTXPush(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPushFwd(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPushInv(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPushInvXpose(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPop(MTXStack* sPtr); +MtxPtr MTXGetStackPtr(const MTXStack* sPtr); + +// VEC +// C versions +void C_VECAdd(const Vec* a, const Vec* b, Vec* ab); +void C_VECSubtract(const Vec* a, const Vec* b, Vec* a_b); +void C_VECScale(const Vec* src, Vec* dst, f32 scale); +void C_VECNormalize(const Vec* src, Vec* unit); +f32 C_VECSquareMag(const Vec* v); +f32 C_VECMag(const Vec* v); +f32 C_VECDotProduct(const Vec* a, const Vec* b); +void C_VECCrossProduct(const Vec* a, const Vec* b, Vec* axb); +f32 C_VECSquareDistance(const Vec* a, const Vec* b); +f32 C_VECDistance(const Vec* a, const Vec* b); + +// PS versions +void PSVECAdd(const Vec* a, const Vec* b, Vec* ab); +void PSVECSubtract(const Vec* a, const Vec* b, Vec* a_b); +void PSVECScale(const Vec* src, Vec* dst, f32 scale); +void PSVECNormalize(const Vec* src, Vec* dst); +f32 PSVECSquareMag(const Vec* v); +f32 PSVECMag(const Vec* v); +f32 PSVECDotProduct(const Vec* a, const Vec* b); +void PSVECCrossProduct(const Vec* a, const Vec* b, Vec* axb); +f32 PSVECSquareDistance(const Vec* a, const Vec* b); +f32 PSVECDistance(const Vec* a, const Vec* b); + +#ifdef DEBUG +#define VECAdd C_VECAdd +#define VECSubtract C_VECSubtract +#define VECScale C_VECScale +#define VECNormalize C_VECNormalize +#define VECSquareMag C_VECSquareMag +#define VECMag C_VECMag +#define VECDotProduct C_VECDotProduct +#define VECCrossProduct C_VECCrossProduct +#define VECSquareDistance C_VECSquareDistance +#define VECDistance C_VECDistance +#else +#define VECAdd PSVECAdd +#define VECSubtract PSVECSubtract +#define VECScale PSVECScale +#define VECNormalize PSVECNormalize +#define VECSquareMag PSVECSquareMag +#define VECMag PSVECMag +#define VECDotProduct PSVECDotProduct +#define VECCrossProduct PSVECCrossProduct +#define VECSquareDistance PSVECSquareDistance +#define VECDistance PSVECDistance +#endif + +void C_VECHalfAngle(const Vec* a, const Vec* b, Vec* half); +void C_VECReflect(const Vec* src, const Vec* normal, Vec* dst); + +#define VECHalfAngle C_VECHalfAngle +#define VECReflect C_VECReflect + +// QUAT +// C versions +void C_QUATAdd(const Quaternion* p, const Quaternion* q, Quaternion* r); +void C_QUATSubtract(const Quaternion* p, const Quaternion* q, Quaternion* r); +void C_QUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq); +void C_QUATScale(const Quaternion* q, Quaternion* r, f32 scale); +f32 C_QUATDotProduct(const Quaternion* p, const Quaternion* q); +void C_QUATNormalize(const Quaternion* src, Quaternion* unit); +void C_QUATInverse(const Quaternion* src, Quaternion* inv); +void C_QUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r); + +// PS versions +void PSQUATAdd(const Quaternion* p, const Quaternion* q, Quaternion* r); +void PSQUATSubtract(const Quaternion* p, const Quaternion* q, Quaternion* r); +void PSQUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq); +void PSQUATScale(const Quaternion* q, Quaternion* r, f32 scale); +f32 PSQUATDotProduct(const Quaternion* p, const Quaternion* q); +void PSQUATNormalize(const Quaternion* src, Quaternion* unit); +void PSQUATInverse(const Quaternion* src, Quaternion* inv); +void PSQUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r); + +#ifdef DEBUG +#define QUATAdd C_QUATAdd +#define QUATSubtract C_QUATSubtract +#define QUATMultiply C_QUATMultiply +#define QUATScale C_QUATScale +#define QUATDotProduct C_QUATDotProduct +#define QUATNormalize C_QUATNormalize +#define QUATInverse C_QUATInverse +#define QUATDivide C_QUATDivide +#else +#define QUATAdd PSQUATAdd +#define QUATSubtract PSQUATSubtract +#define QUATMultiply PSQUATMultiply +#define QUATScale PSQUATScale +#define QUATDotProduct PSQUATDotProduct +#define QUATNormalize PSQUATNormalize +#define QUATInverse PSQUATInverse +#define QUATDivide PSQUATDivide +#endif + +// C versions only +void C_QUATExp(const Quaternion* q, Quaternion* r); +void C_QUATLogN(const Quaternion* q, Quaternion* r); +void C_QUATMakeClosest(const Quaternion* q, const Quaternion* qto, Quaternion* r); +void C_QUATRotAxisRad(Quaternion* r, const Vec* axis, f32 rad); +void C_QUATMtx(Quaternion* r, const Mtx m); +void C_QUATLerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t); +void C_QUATSlerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t); +void C_QUATSquad(const Quaternion* p, const Quaternion* a, const Quaternion* b, const Quaternion* q, Quaternion* r, f32 t); +void C_QUATCompA(const Quaternion* qprev, const Quaternion* q, const Quaternion* qnext, Quaternion* a); + +#define QUATExp C_QUATExp +#define QUATLogN C_QUATLogN +#define QUATMakeClosest C_QUATMakeClosest +#define QUATRotAxisRad C_QUATRotAxisRad +#define QUATMtx C_QUATMtx +#define QUATLerp C_QUATLerp +#define QUATSlerp C_QUATSlerp +#define QUATSquad C_QUATSquad +#define QUATCompA C_QUATCompA + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/revolution/wpad.h b/include/revolution/wpad.h new file mode 100644 index 0000000000..59b27ac5f7 --- /dev/null +++ b/include/revolution/wpad.h @@ -0,0 +1,61 @@ +#ifndef _REVOLUTION_WPAD_H_ +#define _REVOLUTION_WPAD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define WPAD_BUTTON_LEFT 0x0001 +#define WPAD_BUTTON_RIGHT 0x0002 +#define WPAD_BUTTON_DOWN 0x0004 +#define WPAD_BUTTON_UP 0x0008 +#define WPAD_BUTTON_PLUS 0x0010 +#define WPAD_BUTTON_2 0x0100 +#define WPAD_BUTTON_1 0x0200 +#define WPAD_BUTTON_B 0x0400 +#define WPAD_BUTTON_A 0x0800 +#define WPAD_BUTTON_MINUS 0x1000 +#define WPAD_BUTTON_Z 0x2000 +#define WPAD_BUTTON_C 0x4000 +#define WPAD_BUTTON_HOME 0x8000 + +typedef s32 WPADResult; +typedef s32 WPADChannel; +typedef u32 WPADDeviceType; + +typedef void WPADExtensionCallback(WPADChannel chan, s32 devType); + +// for ease of use in for loops +enum WPADChannel_et { + WPAD_CHAN0, + WPAD_CHAN1, + WPAD_CHAN2, + WPAD_CHAN3, + + WPAD_MAX_CONTROLLERS, + WPAD_CHAN_INVALID = -1, +}; + +typedef struct WPADInfo { + /* 0x00 */ BOOL dpd; + /* 0x04 */ BOOL speaker; + /* 0x08 */ BOOL attach; + /* 0x0C */ BOOL lowBat; + /* 0x10 */ BOOL nearempty; + /* 0x14 */ u8 battery; + /* 0x15 */ u8 led; + /* 0x16 */ u8 protocol; + /* 0x17 */ u8 firmware; +} WPADInfo; // size 0x18 + +WPADResult WPADProbe(WPADChannel chan, WPADDeviceType* devType); + +WPADExtensionCallback* WPADSetExtensionCallback(WPADChannel chan, WPADExtensionCallback* cb); + +#ifdef __cplusplus +} +#endif + +#endif // _REVOLUTION_WPAD_H_ diff --git a/src/SSystem/SComponent/c_API_controller_pad.cpp b/src/SSystem/SComponent/c_API_controller_pad.cpp index c8c29794a6..4ac6aad2db 100644 --- a/src/SSystem/SComponent/c_API_controller_pad.cpp +++ b/src/SSystem/SComponent/c_API_controller_pad.cpp @@ -5,13 +5,156 @@ #include "SSystem/SComponent/c_API_controller_pad.h" #include "m_Do/m_Do_controller_pad.h" +#include "global.h" + +#if PLATFORM_WII +#include "m_Do/m_Re_controller_pad.h" +#endif /* 8026328C-802632AC 25DBCC 0020+00 0/0 3/3 0/0 .text cAPICPad_recalibrate__Fv */ void cAPICPad_recalibrate() { mDoCPd_c::recalibrate(); + + #if PLATFORM_WII + mReCPd::stopMoter(); + #endif } /* 802632AC-802632C8 25DBEC 001C+00 0/0 3/3 1/1 .text cAPICPad_ANY_BUTTON__FUl */ u32 cAPICPad_ANY_BUTTON(u32 portNo) { return mDoCPd_c::getTrig(portNo) & (PAD_BUTTON_A | PAD_BUTTON_B | PAD_BUTTON_START); } + +#if PLATFORM_WII +u32 cAPICPad_BUTTON(u32 i_padNo) { + return mReCPd::getHold(i_padNo); +} + +u32 cAPICPad_Z_BUTTON(u32 i_padNo) { + return mReCPd::getHoldUp(i_padNo); +} + +u32 cAPICPad_R_BUTTON(u32 i_padNo) { + return 0; +} + +u32 cAPICPad_L_BUTTON(u32 i_padNo) { + return mReCPd::getHoldZ1(i_padNo); +} + +u32 cAPICPad_A_BUTTON(u32 i_padNo) { + return mReCPd::getHoldA(i_padNo); +} + +u32 cAPICPad_B_BUTTON(u32 i_padNo) { + return mReCPd::getHoldB(i_padNo); +} + +u32 cAPICPad_X_BUTTON(u32 i_padNo) { + return mReCPd::getHoldRight(i_padNo); +} + +u32 cAPICPad_Y_BUTTON(u32 i_padNo) { + return mReCPd::getHoldLeft(i_padNo); +} + +u32 cAPICPad_TRIGGER(u32 i_padNo) { + return mReCPd::getTrig(i_padNo); +} + +u32 cAPICPad_Z_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigUp(i_padNo); +} + +u32 cAPICPad_R_TRIGGER(u32 i_padNo) { + return 0; +} + +u32 cAPICPad_UP_TRIGGER(u32 i_padNo) { + return 0; +} + +u32 cAPICPad_DOWN_TRIGGER(u32 i_padNo) { + return 0; +} + +u32 cAPICPad_LEFT_TRIGGER(u32 i_padNo) { + return 0; +} + +u32 cAPICPad_RIGHT_TRIGGER(u32 i_padNo) { + return 0; +} + +u32 cAPICPad_L_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigZ1(i_padNo); +} + +u32 cAPICPad_A_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigA(i_padNo); +} + +u32 cAPICPad_B_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigB(i_padNo); +} + +u32 cAPICPad_X_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigRight(i_padNo); +} + +u32 cAPICPad_Y_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigLeft(i_padNo); +} + +u32 cAPICPad_START_TRIGGER(u32 i_padNo) { + return mReCPd::getTrigStart(i_padNo); +} + +f32 cAPICPad_X_STICK(u32 i_padNo) { + return mReCPd::getPad(i_padNo).field_0x4[0].ex_status.fs.stick.x; +} + +f32 cAPICPad_X_STICK_3D(u32 i_padNo) { + return mReCPd::getPad(i_padNo).m_stick3D; +} + +f32 cAPICPad_Y_STICK(u32 i_padNo) { + return mReCPd::getPad(i_padNo).field_0x4[0].ex_status.fs.stick.y; +} + +f32 cAPICPad_VALUE_STICK(u32 i_padNo) { + return mReCPd::getPad(i_padNo).m_stickValue; +} + +s16 cAPICPad_ANGLE_STICK(u32 i_padNo) { + return mReCPd::getPad(i_padNo).m_stickAngle; +} + +s16 cAPICPad_ANGLE_STICK_3D(u32 i_padNo) { + return mReCPd::getFSStickAngle3DRev(i_padNo); +} + +f32 cAPICPad_X_SUBSTICK(u32 i_padNo) { + return 0.0f; +} + +f32 cAPICPad_Y_SUBSTICK(u32 i_padNo) { + return 0.0f; +} + +f32 cAPICPad_VALUE_SUBSTICK(u32 i_padNo) { + return 0.0f; +} + +s16 cAPICPad_ANGLE_SUBSTICK(u32 i_padNo) { + return 0; +} + +f32 cAPICPad_L_ANALOG(u32 i_padNo) { + return 0.0f; +} + +f32 cAPICPad_R_ANALOG(u32 i_padNo) { + return 0.0f; +} +#endif diff --git a/src/Z2AudioLib/Z2LinkMgr.cpp b/src/Z2AudioLib/Z2LinkMgr.cpp index 116c987ffb..4367cde681 100644 --- a/src/Z2AudioLib/Z2LinkMgr.cpp +++ b/src/Z2AudioLib/Z2LinkMgr.cpp @@ -4,7 +4,7 @@ // #include "Z2AudioLib/Z2LinkMgr.h" -#include "Z2AudioCSD\Z2AudioCS.h" +#include "Z2AudioLib\Z2AudioCS.h" #include "d/d_com_inf_game.h" /* 802C321C-802C3220 2BDB5C 0004+00 0/0 1/1 0/0 .text setLinkGroupInfo__14Z2CreatureLinkFUc */ diff --git a/src/d/actor/d_a_alink_demo.inc b/src/d/actor/d_a_alink_demo.inc index 280f965341..5d8438cf04 100644 --- a/src/d/actor/d_a_alink_demo.inc +++ b/src/d/actor/d_a_alink_demo.inc @@ -4173,12 +4173,23 @@ static fopAc_ac_c* daAlink_searchPortal(fopAc_ac_c* i_actor, void* i_data) { /* 8011F658-8011F7D8 119F98 0180+00 1/1 0/0 0/0 .text checkAcceptWarp__9daAlink_cFv */ bool daAlink_c::checkAcceptWarp() { + #if VERSION != VERSION_WII_USA_R0 cM3dGPla plane; + #endif - if (mLinkAcch.ChkGroundHit() && !checkModeFlg(MODE_PLAYER_FLY) && - !checkNoResetFlg0(FLG0_UNDERWATER)) + if (mLinkAcch.ChkGroundHit() && !checkModeFlg(MODE_PLAYER_FLY) + #if VERSION != VERSION_WII_USA_R0 + && !checkNoResetFlg0(FLG0_UNDERWATER) + #endif + ) { - if (!getSlidePolygon(&plane) && !checkForestOldCentury()) { + if ( + #if VERSION != VERSION_WII_USA_R0 + !getSlidePolygon(&plane) && + #endif + !checkForestOldCentury() + ) + { if (checkMidnaRide() || ((daMidna_c*)getMidnaActor())->checkPortalObjRide()) { if ((checkField() || checkCastleTown()) && !checkStageName("R_SP161")) { if ((checkWolf() && (checkModeFlg(MODE_UNK_1000) || diff --git a/src/d/d_home_button.cpp b/src/d/d_home_button.cpp index f5604d5624..837695a0f5 100644 --- a/src/d/d_home_button.cpp +++ b/src/d/d_home_button.cpp @@ -1,5 +1,12 @@ #include "d/d_home_button.h" +#include "JSystem/JFramework/JFWDisplay.h" +#include "Z2AudioLib/Z2AudioCS.h" #include "Z2AudioLib/Z2AudioMgr.h" +#include "d/d_com_inf_game.h" +#include "m_Do/m_Do_Reset.h" +#include "m_Do/m_Do_graphic.h" +#include "m_Do/m_Do_lib.h" +#include "m_Do/m_Re_controller_pad.h" int SECallback(int param_0, int param_1) { if (param_0 == 5) { @@ -11,6 +18,40 @@ int SECallback(int param_0, int param_1) { } } +// NONMATCHING - stack +void drawCallback(J2DOrthoGraph& param_0, void* param_1) { + Mtx sp8; + if (mDoGph_gInf_c::isWide()) { + MTXOrtho(sp8, 228.0f, -228.0f, -416.0f, 416.0f, 0.0f, 500.0f); + } else { + MTXOrtho(sp8, 228.0f, -228.0f, -304.0f, 304.0f, 0.0f, 500.0f); + } + + GXSetProjection(sp8, GX_ORTHOGRAPHIC); + GXClearVtxDesc(); + GXSetVtxAttrFmt(GX_VTXFMT4, GX_VA_POS, GX_POS_XY, GX_F32, 0); + GXSetVtxAttrFmt(GX_VTXFMT4, GX_VA_CLR0, GX_CLR_RGB, GX_RGB8, 0); + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT); + GXSetNumChans(1); + GXSetNumTexGens(0); + GXSetNumTevStages(1); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0); + GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR); + GXSetBlendMode(GX_BM_NONE, GX_BL_ZERO, GX_BL_ZERO, GX_LO_CLEAR); + GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE); + GXSetCullMode(GX_CULL_NONE); + GXLoadPosMtxImm(g_mDoMtx_identity, 3); + GXSetCurrentMtx(3); + + HBMDraw(); +} + +dHomeButton_c* dHomeButton_c::m_myObj; + +u8 dHomeButton_c::lbl_8053A724; +u8 dHomeButton_c::lbl_8053A725; + void dHomeButton_c::create_(int param_0, void* param_1) { initCursorPos(); initHomeButtonInfo(param_0, param_1); @@ -22,34 +63,187 @@ void dHomeButton_c::create_(int param_0, void* param_1) { HBMCreate(&m_info); } +// NONMATCHING int dHomeButton_c::execute_() { - // NONMATCHING + if (m_myObj == NULL) { + return 0; + } + + calcCursorPos(); + + if (field_0x7c == 0 && !mDoRst::isReset()) { + bool var_r30 = false; + for (u32 i = 0; i < 4; i++) { + if (mReCPd::chkDevTypeValid(i) && mReCPd::getTrigHome(i)) { + var_r30 = true; + } + } + + if (var_r30) { + mReCPd::enableDpd(0); + Z2AudioCS::disconnect(0); + + HBMSetAdjustFlag(mDoGph_gInf_c::isWide()); + HBMInit(); + + mDoGph_gInf_c::setTickRate(OS_TIMER_CLOCK / 60); + field_0x7c = 1; + lbl_8053A724 = 0; + } + } + + if (field_0x7c) { + if (lbl_8053A724 == 0 && mDoRst::isReset()) { + HBMStartBlackOut(); + onReset(); + } + + if (HBMCalc(&m_controllerData) >= HBM_SELECT_HOMEBTN) { + int selectBtn = HBMGetSelectBtnNum(); + if (selectBtn == HBM_SELECT_BTN1) { + mDoRst::onReturnToMenu(); + onReset(); + } else if (selectBtn == HBM_SELECT_BTN2) { + mDoRst_resetCallBack(-1, NULL); + onReset(); + } + + Z2AudioCS::connect(0); + mDoGph_gInf_c::setTickRate(field_0x78); + field_0x7c = 0; + mReCPd::setExtensionCallback(); + } else { + drawCapture(0xFF, drawCallback, NULL); + } + } + + return field_0x7c; } -void dHomeButton_c::initHomeButtonInfo(int param_0, void* param_1) { - // NONMATCHING +void dHomeButton_c::initHomeButtonInfo(int param_0, void* i_layoutBuf) { + m_info.layoutBuf = i_layoutBuf; + m_info.spkSeBuf = dComIfG_getObjectRes("HomeBtn", "SpeakerSe.arc"); + m_info.msgBuf = dComIfG_getObjectRes("HomeBtn", "home.csv"); + m_info.configBuf = dComIfG_getObjectRes("HomeBtn", "config.txt"); + m_info.sound_callback = SECallback; + m_info.backFlag = 0; + m_info.region = param_0; + m_info.cursor = 0; + + m_info.adjust.x = 1.3684211f; + m_info.adjust.y = 1.0f; + m_info.frameDelta = 1.0f; } void dHomeButton_c::initCursorPos() { - // NONMATCHING + for (int i = 0; i < 4; i++) { + m_controllerData.wiiCon[i].pos.x = 0.0f; + m_controllerData.wiiCon[i].pos.y = 0.0f; + m_controllerData.wiiCon[i].use_devtype = 0; + } } void dHomeButton_c::calcCursorPos() { - // NONMATCHING + for (u32 i = 0; i < 4; i++) { + WPADDeviceType sp8; + WPADResult result = WPADProbe(i, &sp8); + + if (result == -2 || result == -3 || result == 0) { + m_controllerData.wiiCon[i].kpad = &mReCPd::m_pad[i].field_0x4[0]; + } else { + m_controllerData.wiiCon[i].kpad = NULL; + } + } } void dHomeButton_c::onReset() { - // NONMATCHING + mDoGph_gInf_c::setFadeColor(*(JUtility::TColor*)&g_blackColor); + lbl_8053A724 = 1; } void dHomeButton_c::create(int param_0, void* param_1) { - // NONMATCHING + m_myObj = new dHomeButton_c(); + m_myObj->create_(param_0, param_1); } int dHomeButton_c::execute() { - // NONMATCHING + if (m_myObj) { + return m_myObj->execute_(); + } + + return NULL; } +// NONMATCHING void dHomeButton_c::drawCapture(u8 param_0, void (*param_1)(J2DOrthoGraph&, void*), void* param_2) { - // NONMATCHING + if (lbl_8053A725 == 0) { + GXSetTexCopySrc(0, 0, 640, 456); + GXSetTexCopyDst(640, 456, (GXTexFmt)mDoGph_gInf_c::m_fullFrameBufferTimg->format, GX_FALSE); + GXCopyTex(mDoGph_gInf_c::m_fullFrameBufferTex, GX_FALSE); + lbl_8053A725 = 1; + } + + JFWDisplay::getManager()->setClearColor(g_clearColor); + mDoGph_gInf_c::beginRender(); + GXSetAlphaUpdate(GX_DISABLE); + j3dSys.drawInit(); + + J2DOrthoGraph sp30(0.0f, 0.0f, 640.0f, 456.0f, -1.0f, 1.0f); + sp30.setOrtho(JGeometry::TBox2(mDoGph_gInf_c::getMinXF(), mDoGph_gInf_c::getMinYF(), + mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), + mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF()), + -1.0f, 1.0f); + sp30.setPort(); + + dComIfGp_setCurrentGrafPort(&sp30); + mDoLib_setResTimgObj(mDoGph_gInf_c::m_fullFrameBufferTimg, + &mDoGph_gInf_c::m_fullFrameBufferTexObj, 0, NULL); + + GXLoadTexObj(&mDoGph_gInf_c::m_fullFrameBufferTexObj, GX_TEXMAP0); + GXSetNumChans(0); + GXSetNumIndStages(0); + GXSetNumTexGens(1); + GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 60); + GXSetNumTevStages(1); + + GXColor sp14 = {0, 0, 0, param_0}; + GXSetTevColor(GX_TEVREG0, sp14); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_TEXC, GX_CC_A0, GX_CC_ZERO); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetZCompLoc(GX_TRUE); + GXSetZMode(GX_DISABLE, GX_ALWAYS, GX_DISABLE); + GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR); + GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0); + GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor); + GXSetFogRangeAdj(GX_DISABLE, 0, NULL); + GXSetCullMode(GX_CULL_NONE); + GXSetDither(GX_TRUE); + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_S8, 0); + GXBegin(GX_QUADS, GX_VTXFMT0, 4); + + GXPosition2f32(mDoGph_gInf_c::getMinXF(), mDoGph_gInf_c::getMinYF()); + GXTexCoord2u8(0, 0); + + GXPosition2f32(mDoGph_gInf_c::getMaxXF(), mDoGph_gInf_c::getMinYF()); + GXTexCoord2u8(1, 0); + + GXPosition2f32(mDoGph_gInf_c::getMaxXF(), mDoGph_gInf_c::getMaxYF()); + GXTexCoord2u8(1, 1); + + GXPosition2f32(mDoGph_gInf_c::getMinXF(), mDoGph_gInf_c::getMaxYF()); + GXTexCoord2u8(0, 1); + + if (param_1 != NULL) { + param_1(sp30, param_2); + } + + JFWDisplay::getManager()->endRender(); + JFWDisplay::getManager()->setFader(NULL); } diff --git a/src/m_Do/m_Re_controller_pad.cpp b/src/m_Do/m_Re_controller_pad.cpp index e69de29bb2..24a97449dd 100644 --- a/src/m_Do/m_Re_controller_pad.cpp +++ b/src/m_Do/m_Re_controller_pad.cpp @@ -0,0 +1,350 @@ +#include "m_Do/m_Re_controller_pad.h" +#include "Z2AudioLib/Z2AudioCS.h" + +mReCPd::Pad mReCPd::m_pad[4]; +WPADInfo mReCPd::m_pad_info[4]; + +void mReCPd::Pad::Acc::clean() { + +} + +void mReCPd::Pad::Acc::changeStts(u32, bool) { + +} + +void mReCPd::Pad::Acc::calcSwingVec() { + +} + +void mReCPd::Pad::Acc::calcSttsRem() { + +} + +void mReCPd::Pad::Acc::calcSttsFs() { + +} + +void mReCPd::Pad::clean() { + +} + +void mReCPd::Pad::cleanOneTime() { + +} + +void mReCPd::Pad::copyRemAcc() { + +} + +void mReCPd::Pad::copyFSAcc() { + +} + +void mReCPd::Pad::cleanTrig() { + m_remAcc.m_swing = 0; + m_FSAcc.m_swing = 0; + + for (int i = 0; i < 10; i++) { + field_0x4[i].trig = 0; + } +} + +void mReCPd::Pad::cleanHold() { + for (int i = 0; i < 10; i++) { + field_0x4[i].hold = 0; + } +} + +void mReCPd::Pad::cleanRelease() { + for (int i = 0; i < 10; i++) { + field_0x4[i].release = 0; + } +} + +void mReCPd::Pad::clearUpDown() { + +} + +void mReCPd::Pad::calcDpdBox(Vec2*, Vec2*, f32, f32) { + +} + +void mReCPd::Pad::calcDpdOld() { + +} + +void mReCPd::enableDpd(u32 param_0) { + KPADEnableDPD(param_0); +} + +void mReCPd::disableDpd(u32 param_0) { + KPADDisableDPD(param_0); +} + +void mReCPd::Pad::calcDpd2DPos() { + +} + +void mReCPd::Pad::calcDpdRatioPos() { + +} + +void mReCPd::Pad::calcDpdPlayCirPos() { + +} + +void mReCPd::Pad::calcDpdPlayBoxPos() { + +} + +void mReCPd::onConnect(u32 i_padNo) { + m_pad[i_padNo].field_0x1dd4 = 1; + m_pad[i_padNo].field_0x1e04 = 1; +} + +static void l_mReCPd_extensionCallback(s32 i_padNo, s32 param_1) { + Z2AudioCS::extensionProcess(i_padNo, param_1); + mReCPd::m_pad[i_padNo].field_0x1dec = param_1; + mReCPd::m_pad[i_padNo].field_0x1df0 = 1; +} + +void mReCPd::setExtensionCallback() { + WPADSetExtensionCallback(0, l_mReCPd_extensionCallback); +} + +void mReCPd::onGetInfoAsync(u32 i_padNo) { + m_pad[i_padNo].field_0x1ddd = 1; + m_pad[i_padNo].field_0x1de0 = 1800; +} + +void mReCPd::create() { + +} + +void mReCPd::startMoterWave(motorWave_t*, u8*, bool) { + +} + +void mReCPd::startMoterWave(int, u8*, bool) { + +} + +void mReCPd::stopMoterWave(motorWave_t*) { + +} + +void mReCPd::stopMoterWave(int) { + +} + +void mReCPd::updateMoterWave() { + +} + +void mReCPd::stopMoter() { + +} + +void mReCPd::getLowBat(u32) { + +} + +void mReCPd::setLowBat(u32, int) { + +} + +void mReCPd::onLowBatChk(u32) { + +} + +void mReCPd::procNoData(u32) { + +} + +void mReCPd::read() { + +} + +void mReCPd::calibrateDist(int) { + +} + +void mReCPd::getDpd2DPos(u32) { + +} + +void mReCPd::getDpdRatioPos(u32) { + +} + +void mReCPd::getDpdRatioBoxPos(u32) { + +} + +void mReCPd::chkDpdOk(u32) { + +} + +void mReCPd::chkDpdValid(u32) { + +} + +void mReCPd::chkDpdPosIn(u32) { + +} + +void mReCPd::getKPADAcc(u32, Vec*, int) { + +} + +void mReCPd::getAngleXy(u32) { + +} + +void mReCPd::getAngleZy(u32) { + +} + +void mReCPd::getKPADAccValue(u32, int) { + +} + +void mReCPd::getKPADAccValueMax(u32) { + +} + +void mReCPd::getKPADAccSpeed(u32, int) { + +} + +void mReCPd::getKPADAccSpeedMax(u32) { + +} + +void mReCPd::getKPADFsAccValue(u32, int) { + +} + +void mReCPd::getKPADFsAccValueMax(u32) { + +} + +s16 mReCPd::getFSStickAngle3DRev(u32) { + +} + +void mReCPd::calcUnderVec(Pad::Acc*, f32) { + +} + +u32 mReCPd::getHoldB(u32 i_padNo) { + return m_pad[i_padNo].field_0x4[0].hold & WPAD_BUTTON_B; +} + +u32 mReCPd::getHoldMinus(u32 i_padNo) { + if (chkSwingBlock(i_padNo)) { + return 0; + } else { + return m_pad[i_padNo].field_0x4[0].hold & WPAD_BUTTON_MINUS; + } +} + +u32 mReCPd::getHoldPlus(u32 i_padNo) { + if (chkSwingBlock(i_padNo)) { + return 0; + } else { + return m_pad[i_padNo].field_0x4[0].hold & WPAD_BUTTON_PLUS; + } +} + +u32 mReCPd::getHoldZ1(u32 i_padNo) { + return m_pad[i_padNo].field_0x4[0].hold & WPAD_BUTTON_Z; +} + +u32 mReCPd::getTrigB(u32 i_padNo) { + return m_pad[i_padNo].field_0x4[0].trig & WPAD_BUTTON_B; +} + +u32 mReCPd::getTrigMinus(u32 i_padNo) { + if (chkSwingBlock(i_padNo)) { + return 0; + } else { + return m_pad[i_padNo].field_0x4[0].trig & WPAD_BUTTON_MINUS; + } +} + +u32 mReCPd::getTrigHome(u32 i_padNo) { + if (chkSwingBlock(i_padNo)) { + return 0; + } else { + return m_pad[i_padNo].field_0x4[0].trig & WPAD_BUTTON_HOME; + } +} + +u32 mReCPd::getTrigPlus(u32 i_padNo) { + if (chkSwingBlock(i_padNo)) { + return 0; + } else { + return m_pad[i_padNo].field_0x4[0].trig & WPAD_BUTTON_PLUS; + } +} + +u32 mReCPd::getTrigZ1(u32 i_padNo) { + return m_pad[i_padNo].field_0x4[0].trig & WPAD_BUTTON_Z; +} + +u32 mReCPd::chkSwingBlock(u32 i_padNo) { + return m_pad[i_padNo].m_swingBlock > 0; +} + +u32 mReCPd::getTrigSwing(u32 i_padNo) { + return m_pad[i_padNo].m_remAcc.m_swing; +} + +Vec2& mReCPd::getSwingVec(u32 i_padNo) { + return m_pad[i_padNo].m_remAcc.m_swingVec; +} + +u32 mReCPd::chkSimpleProbe(u32 i_padNo) { + if (m_pad[i_padNo].field_0x1dd4 == 0) { + return 0; + } else if (m_pad[i_padNo].field_0x1dfc + 3 <= 2) { + return 0; + } else if (m_pad[i_padNo].field_0x1df8 == 0xFD || m_pad[i_padNo].field_0x1df8 == 0xFF) { + return 0; + } else { + return 1; + } +} + +BOOL mReCPd::chkDevTypeValid(u32 i_padNo) { + if (!chkSimpleProbe(i_padNo)) { + return FALSE; + } + + if (m_pad[i_padNo].field_0x1df4 < 20 && m_pad[i_padNo].field_0x1de4 == 0xFF && m_pad[i_padNo].field_0x1de8 != 0) { + return FALSE; + } + + return TRUE; +} + +u32 mReCPd::getFSTrigSwing(u32 i_padNo) { + return m_pad[i_padNo].m_FSAcc.m_swing; +} + +int mReCPd::m_cal_value; + +void mReCPd::plusCalValue() { + m_cal_value++; + if (m_cal_value >= 2) { + m_cal_value = 2; + } +} + +void mReCPd::minusCalValue() { + m_cal_value--; + if (m_cal_value <= -2) { + m_cal_value = -2; + } +}