mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-06-10 20:28:19 -04:00
Code Issues Packages Projects Releases Wiki Activity

d_vibration / JUTGamePad matched + linked (#2256)

Browse Source 
* d_vibration done

* JUTGamePad done

* cleanup JUTGamePad

* d_menu_window cleanup
This commit is contained in:
TakaRikka
2024-12-02 11:15:03 -08:00
committed by GitHub
parent edd56f3405
commit 2f77c7f9ec
19 changed files with 1141 additions and 2223 deletions
Download Patch File Download Diff File Expand all files Collapse all files
configure.py
+2 -2
View File
@@ -476,7 +476,7 @@ config.libs = [
Object(Matching, "d/d_kankyo_data.cpp"),
Object(Matching, "d/d_kankyo_wether.cpp"),
Object(NonMatching, "d/d_kankyo_rain.cpp"),
Object(NonMatching, "d/d_vibration.cpp"),
Object(Matching, "d/d_vibration.cpp"),
Object(Matching, "d/d_vib_pattern.cpp"),
Object(NonMatching, "d/d_attention.cpp"),
Object(Matching, "d/d_bg_pc.cpp"),
@@ -942,7 +942,7 @@ config.libs = [
Object(Matching, "JSystem/JUtility/JUTFont.cpp"),
Object(Matching, "JSystem/JUtility/JUTResFont.cpp", extra_cflags=['-pragma "nosyminline off"']),
Object(Matching, "JSystem/JUtility/JUTDbPrint.cpp"),
Object(NonMatching, "JSystem/JUtility/JUTGamePad.cpp"),
Object(Matching, "JSystem/JUtility/JUTGamePad.cpp"),
Object(NonMatching, "JSystem/JUtility/JUTException.cpp"),
Object(Matching, "JSystem/JUtility/JUTDirectPrint.cpp"),
Object(Matching, "JSystem/JUtility/JUTAssert.cpp"),
include/JSystem/JSupport/JSUList.h
+1 -1
View File
@@ -168,7 +168,7 @@ public:
T& operator*() { return *this->getObject(); }
T* operator->() { return this->getObject(); }
T* operator->() const { return mLink->getObject(); }
// private:
JSULink<T>* mLink;
include/JSystem/JUtility/JUTException.h
+1 -1
View File
@@ -104,7 +104,7 @@ public:
void setTraceSuppress(u32 param_0) { mTraceSuppress = param_0; }
void setGamePad(JUTGamePad* gamePad) {
mGamePad = gamePad;
mGamePadPort = JUTGamePad::Port_Unknown;
mGamePadPort = JUTGamePad::EPortInvalid;
}
static void setMapFile(const char* map) {
include/JSystem/JUtility/JUTGamePad.h
+82 -105
View File
@@ -2,38 +2,21 @@
#define JUTGAMEPAD_H
#include "JSystem/JKernel/JKRDisposer.h"
#include "dolphin/os/OSTime.h"
#include "dolphin/pad.h"
#include "JSystem/JUtility/JUTAssert.h"
#include <dolphin.h>
typedef void (*callbackFn)(int, void*);
namespace CButton {
enum {
DPAD_LEFT = 0x0001,
DPAD_RIGHT = 0x0002,
DPAD_DOWN = 0x0004,
DPAD_UP = 0x0008,
Z = 0x0010,
R = 0x0020,
L = 0x0040,
A = 0x0100,
B = 0x0200,
X = 0x0400,
Y = 0x0800,
START = 0x1000,
};
}
extern bool sResetSwitchPushing__Q210JUTGamePad13C3ButtonReset;
/**
* @ingroup jsystem-jutility
*
*/
struct JUTGamePadRecordBase {
virtual void unk0() {}
virtual void unk1(PADStatus* pad) {}
virtual void unk2() {}
virtual ~JUTGamePadRecordBase() {}
virtual void getStatus(PADStatus* pad) = 0;
virtual void write(PADStatus* pad) = 0;
bool isActive() const { return mActive; }
/* 0x4 */ bool mActive;
};
@@ -45,35 +28,44 @@ struct JUTGamePadRecordBase {
struct JUTGamePad : public JKRDisposer {
public:
enum EStickMode {
STICK_MODE_1 = 1,
EStickMode1 = 1,
};
enum EWhichStick {
WS_MAIN_STICK,
WS_SUB_STICK,
EMainStick,
ESubStick,
};
enum EPadPort {
Port_Unknown = -1,
Port_1,
Port_2,
Port_3,
Port_4,
EPortInvalid = -1,
EPort1,
EPort2,
EPort3,
EPort4,
};
enum EClampMode {
EClampNone,
EClampStick,
EClampCircle,
};
JUTGamePad(JUTGamePad::EPadPort port);
virtual ~JUTGamePad();
void initList();
static s32 init();
static BOOL init();
void clear();
static u32 read();
void assign();
void checkResetCallback(OSTime unk);
void checkResetCallback(OSTime holdTime);
void update();
void stopPatternedRumble() { mRumble.stopPatternedRumble(mPortNum); }
static void checkResetSwitch();
static void clearForReset();
static JUTGamePad* getGamePad(int pad_index);
static bool recalibrate(u32 pad_mask);
static JUTGamePad* getGamePad(int port);
static bool recalibrate(u32 mask);
static void setAnalogMode(u32 mode) {
sAnalogMode = mode;
@@ -82,59 +74,39 @@ public:
static void clearResetOccurred() { C3ButtonReset::sResetOccurred = false; }
static void setResetCallback(callbackFn callback, void* param_0) {
static void setResetCallback(callbackFn callback, void* arg) {
C3ButtonReset::sCallback = callback;
C3ButtonReset::sCallbackArg = param_0;
C3ButtonReset::sCallbackArg = arg;
}
u32 getButton() const { return mButton.mButton; }
u32 getTrigger() const { return mButton.mTrigger; }
f32 getMainStickX() const { return mMainStick.mPosX; }
f32 getMainStickY() const { return mMainStick.mPosY; }
f32 getMainStickValue() const { return mMainStick.mValue; }
s16 getMainStickAngle() const { return mMainStick.mAngle; }
f32 getSubStickX() const { return mSubStick.mPosX; }
f32 getSubStickY() const { return mSubStick.mPosY; }
f32 getSubStickValue() const { return mSubStick.mValue; }
s16 getSubStickAngle() const { return mSubStick.mAngle; }
u8 getAnalogA() const { return mButton.mAnalogA; }
u8 getAnalogB() const { return mButton.mAnalogB; }
u8 getAnalogL() const { return mButton.mAnalogL; }
u8 getAnalogR() const { return mButton.mAnalogR; }
s8 getErrorStatus() const { return mErrorStatus; }
s16 getPortNum() const { return mPortNum; }
JUTGamePadRecordBase* getPadReplay() const { return mPadReplay; }
JUTGamePadRecordBase* getPadRecord() const { return mPadRecord; }
u32 testTrigger(u32 button) const { return mButton.mTrigger & button; }
bool isPushing3ButtonReset() const {
bool isPushingReset = false;
if (mPortNum != -1 && mButtonReset.mReset != false) {
isPushingReset = true;
}
return isPushingReset;
return mPortNum != EPortInvalid && mButtonReset.mReset != false;
}
inline void stopMotorWave() { mRumble.stopPatternedRumbleAtThePeriod(); }
void stopMotorWave() { mRumble.stopPatternedRumbleAtThePeriod(); }
void stopMotor() { mRumble.stopMotor(mPortNum, false); }
void stopMotorHard() { mRumble.stopMotorHard(mPortNum); }
@@ -143,8 +115,8 @@ public:
struct CButton {
CButton() { clear(); }
void clear();
void update(PADStatus const*, u32 unk);
void setRepeat(u32 unk0, u32 unk1, u32 unk2);
void update(const PADStatus* padStatus, u32 stickStatus);
void setRepeat(u32 mask, u32 delay, u32 rate);
/* 0x00 */ u32 mButton;
/* 0x04 */ u32 mTrigger; // Pressed Buttons
@@ -156,11 +128,11 @@ public:
/* 0x10 */ f32 mAnalogLf;
/* 0x14 */ f32 mAnalogRf;
/* 0x18 */ u32 mRepeat;
/* 0x1C */ u32 field_0x1c;
/* 0x20 */ u32 field_0x20;
/* 0x24 */ u32 field_0x24;
/* 0x28 */ u32 field_0x28;
/* 0x2C */ u32 field_0x2c;
/* 0x1C */ u32 mRepeatCount;
/* 0x20 */ u32 mRepeatStart;
/* 0x24 */ u32 mRepeatMask;
/* 0x28 */ u32 mRepeatDelay;
/* 0x2C */ u32 mRepeatRate;
}; // Size: 0x30
struct C3ButtonReset {
@@ -185,16 +157,16 @@ public:
CStick() { clear(); }
void clear();
void clear(JUTGamePad* pad);
u32 update(s8 unk0, s8 unk1, JUTGamePad::EStickMode mode, JUTGamePad::EWhichStick stick,
u32 unk2);
u32 getButton(u32 unk);
u32 update(s8 x, s8 u, JUTGamePad::EStickMode mode, JUTGamePad::EWhichStick stick,
u32 buttons);
u32 getButton(u32 buttons);
/* 0x0 */ f32 mPosX;
/* 0x4 */ f32 mPosY;
/* 0x8 */ f32 mValue;
/* 0xC */ s16 mAngle;
/* 0xE */ s8 field_0xe;
/* 0xF */ s8 field_0xf;
/* 0xE */ s8 mRawX;
/* 0xF */ s8 mRawY;
}; // Size: 0x10
void stopMotorWaveHard() { mRumble.stopPatternedRumble(mPortNum); }
@@ -214,31 +186,48 @@ public:
void clear();
void clear(JUTGamePad* pad);
static void startMotor(int channel);
static void stopMotor(int channel, bool stop);
void update(s16 unk0);
void triggerPatternedRumble(u32 unk0);
void startPatternedRumble(void* unk0, ERumble rumble, u32 unk1);
void stopPatternedRumble(s16 pad_port);
static void startMotor(int port);
static void stopMotor(int port, bool hard_stop);
void update(s16 port);
void triggerPatternedRumble(u32 length);
void startPatternedRumble(void* data, ERumble rumble, u32 length);
void stopPatternedRumble(s16 port);
void stopPatternedRumbleAtThePeriod();
static void setEnabled(u32 pad_mask);
static void setEnabled(u32 mask);
void stopMotorHard(int portNo) { stopMotor(portNo, true); }
void stopMotorHard(int port) { stopMotor(port, true); }
static bool isEnabled(u32 mask) { return mEnabled & mask; }
static bool isEnabledPort(int port) { return isEnabled(sChannelMask[port]); }
/* 0x00 */ u32 field_0x0;
/* 0x04 */ u32 field_0x4;
/* 0x08 */ u8* field_0x8;
/* 0x0C */ u32 field_0xc;
static bool isEnabledPort(int port) {
JUT_ASSERT(250, 0 <= port && port < 4);
return isEnabled(sChannelMask[port]);
}
/* 0x00 */ u32 mFrame;
/* 0x04 */ u32 mLength;
/* 0x08 */ u8* mPattern;
/* 0x0C */ u32 mFrameCount;
/* 0x10 */ u8* field_0x10;
}; // Size: 0x14
void startMotorWave(void* param_2, CRumble::ERumble rumble, u32 param_4) {
mRumble.startPatternedRumble(param_2, rumble, param_4);
void startMotorWave(void* data, CRumble::ERumble rumble, u32 length) {
mRumble.startPatternedRumble(data, rumble, length);
}
static JSUList<JUTGamePad> mPadList;
static bool mListInitialized;
static PADStatus mPadStatus[4];
static CButton mPadButton[4];
static CStick mPadMStick[4];
static CStick mPadSStick[4];
static EStickMode sStickMode;
static int sClampMode;
static u8 mPadAssign[4];
static u32 sSuppressPadReset;
static s32 sAnalogMode;
static u32 sRumbleSupported;
/* 0x18 */ CButton mButton;
/* 0x48 */ CStick mMainStick;
/* 0x58 */ CStick mSubStick;
@@ -250,21 +239,8 @@ public:
/* 0x94 */ JUTGamePadRecordBase* mPadReplay;
/* 0x98 */ C3ButtonReset mButtonReset;
/* 0x9C */ u8 field_0x9c[4];
/* 0xA0 */ OSTime mResetTime;
/* 0xA0 */ OSTime mResetHoldStartTime;
/* 0xA8 */ u8 field_0xa8;
static JSUList<JUTGamePad> mPadList;
static bool mListInitialized;
static PADStatus mPadStatus[4];
static CButton mPadButton[4];
static CStick mPadMStick[4];
static CStick mPadSStick[4];
static EStickMode sStickMode;
static u32 sClampMode;
static u8 mPadAssign[4];
static u32 sSuppressPadReset;
static s32 sAnalogMode;
static u32 sRumbleSupported;
};
/**
@@ -273,19 +249,20 @@ public:
*/
struct JUTGamePadLongPress {
static JSUList<JUTGamePadLongPress> sPatternList;
void checkCallback(int port, u32 timer);
void checkCallback(int port, u32 hold_time);
u32 getMaskPattern() const { return mMaskPattern; }
u32 getPattern() const { return mPattern; }
bool isValid() const { return mValid; }
/* 0x00 */ u8 field_0x0[0x10];
/* 0x10 */ bool mValid;
/* 0x11 */ bool field_0x11;
/* 0x14 */ u32 mPattern;
/* 0x18 */ u32 mMaskPattern;
/* 0x1C */ u32 field_0x1c;
/* 0x20 */ bool field_0x20[4];
/* 0x28 */ OSTime mTimer[4];
/* 0x1C */ u32 mThreshold;
/* 0x20 */ bool mLongPressStatus[4];
/* 0x28 */ OSTime mStartHoldTime[4];
/* 0x48 */ bool field_0x48[4];
/* 0x4C */ void (*mCallback)(s32, JUTGamePadLongPress*, s32);
/* 0x50 */ s32 field_0x50;
include/d/d_menu_window.h
+11 -15
View File
@@ -4,6 +4,8 @@
#include "d/d_drawlist.h"
#include "f_op/f_op_msg.h"
#include "m_Do/m_Do_graphic.h"
#include "d/d_com_inf_game.h"
#include "JSystem/JUtility/JUTTexture.h"
struct CSTControl;
class STControl;
@@ -29,7 +31,7 @@ BOOL dMw_START_TRIGGER();
class dDlst_MENU_CAPTURE_c : public dDlst_base_c {
public:
/* 801FDFCC */ virtual void draw();/* {
virtual void draw() {
if (getDrawFlag() == 1) {
setDrawFlag();
dComIfGp_onPauseFlag();
@@ -50,7 +52,7 @@ public:
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_TEXC);
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
GXColor color = {0xFF, 0xFF, 0xFF, mAlpha};
const GXColor color = {0, 0, 0, mAlpha};
GXSetTevColor(GX_TEVREG0, color);
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
@@ -84,8 +86,9 @@ public:
GXTexCoord2s8(0, 1);
GXEnd();
}
} */
/* 801FE2E8 */ virtual ~dDlst_MENU_CAPTURE_c();
}
virtual ~dDlst_MENU_CAPTURE_c() {}
dDlst_MENU_CAPTURE_c() {
mFlag = 0;
@@ -256,6 +259,7 @@ public:
void onPauseWindow() { mPauseWindow = true; }
void offPauseWindow() { mPauseWindow = false; }
bool isPauseWindow() { return mPauseWindow != false; }
void onShowFlag() { mShowFlag |= 1; }
void offShowFlag() { mShowFlag &= ~1; }
bool isShowFlag() { return mShowFlag & 1 != 0; }
@@ -277,12 +281,12 @@ private:
/* 0x12C */ dMenu_Fishing_c* mpMenuFishing;
/* 0x130 */ dMenu_Skill_c* mpMenuSkill;
/* 0x134 */ dMenu_Insect_c* mpMenuInsect;
/* 0x138 */ s32 mMemSize;
/* 0x138 */ int mMemSize;
/* 0x13C */ f32 mFmapStageTransX;
/* 0x140 */ f32 mFmapStageTransZ;
/* 0x144 */ u8 field_0x144;
/* 0x145 */ u8 mButtons;
/* 0x146 */ u8 mMenuStatus;
/* 0x145 */ u8 mButtonBits;
/* 0x146 */ u8 mMenuProc;
/* 0x147 */ u8 mShowFlag;
/* 0x148 */ s8 field_0x148;
/* 0x149 */ u8 field_0x149;
@@ -302,12 +306,4 @@ private:
BOOL dMw_LEFT_TRIGGER();
BOOL dMw_RIGHT_TRIGGER();
static int dMw_Draw(dMw_c*);
static int dMw_Execute(dMw_c*);
static int dMw_IsDelete(dMw_c*);
static int dMw_Delete(dMw_c*);
static int dMw_Create(msg_class*);
typedef int (*dMw_Method)(dMw_c*);
#endif /* D_MENU_D_MENU_WINDOW_H */
include/d/d_meter2_info.h
+5
View File
@@ -191,6 +191,7 @@ public:
f32 get2DHeight() { return m2DHeight; }
u8 getTableMapRegionNo() { return mTableMapRegionNo; }
u8 getGoldWolfMapType() { return mGoldWolfMapType; }
bool isWindowAccept(int param_0) { return mWindowAccept & (1 << param_0); }
public:
/* 0x04 */ u8 unk4[4];
@@ -789,6 +790,10 @@ inline u8 dMeter2Info_getGoldWolfMapType() {
return g_meter2_info.getGoldWolfMapType();
}
inline bool dMeter2Info_isWindowAccept(int param_0) {
return g_meter2_info.isWindowAccept(param_0);
}
const char* dMeter2Info_getPlusTextureName();
const char* dMeter2Info_getNumberTextureName(int pIndex);
int dMeter2Info_recieveLetter();
include/d/d_vib_pattern.h
+1 -6
View File
@@ -3,11 +3,6 @@
#include "dolphin/types.h"
class dVibration_pattern {
public:
u16 field_0x00;
u16 field_0x02;
u32 field_0x04;
};
#endif /* D_D_VIB_PATTERN_H */
include/d/d_vibration.h
+76 -33
View File
@@ -2,15 +2,59 @@
#define D_D_VIBRATION_H
#include "SSystem/SComponent/c_xyz.h"
#include "d/d_vib_pattern.h"
struct vib_pattern {
/* 0x0 */ u16 rounds;
/* 0x2 */ u16 length;
/* 0x4 */ u32 bits;
};
class dVibration_c {
public:
enum {
MODE_PAUSE = -1,
MODE_WAIT,
MODE_RUN,
};
enum VIBMODE_SHOCK {
VIBMODE_S_NONE = -1,
VIBMODE_S_CUSTOM,
VIBMODE_S_POWER1,
VIBMODE_S_POWER2,
VIBMODE_S_POWER3,
VIBMODE_S_POWER4,
VIBMODE_S_POWER5,
VIBMODE_S_POWER6,
VIBMODE_S_POWER7,
VIBMODE_S_POWER8,
VIBMODE_S_DOKUTT,
VIBMODE_S_FOR2D,
VIBMODE_S_MAX
};
enum VIBMODE_QUAKE {
VIBMODE_Q_NONE = -1,
VIBMODE_Q_CUSTOM,
VIBMODE_Q_POWER1,
VIBMODE_Q_POWER2,
VIBMODE_Q_POWER3,
VIBMODE_Q_POWER4,
VIBMODE_Q_POWER5,
VIBMODE_Q_POWER6,
VIBMODE_Q_POWER7,
VIBMODE_Q_POWER8,
VIBMODE_Q_HORSE,
VIBMODE_Q_MAX
};
/* 8006F268 */ int Run();
/* 8006FA24 */ bool StartShock(int i_strength, int, cXyz);
/* 8006FC0C */ bool StartQuake(u8 const*, int, int, cXyz);
/* 8006FB10 */ bool StartQuake(int, int, cXyz);
/* 8006FD94 */ int StopQuake(int);
/* 8006FA24 */ bool StartShock(int i_vibmode, int i_flags, cXyz i_pos);
/* 8006FC0C */ bool StartQuake(const u8* i_pattern, int i_rounds, int i_flags, cXyz i_pos);
/* 8006FB10 */ bool StartQuake(int i_vibmode, int i_flags, cXyz i_pos);
/* 8006FD94 */ int StopQuake(int i_flags);
/* 8006FE00 */ void Kill();
/* 8006FE5C */ bool CheckQuake();
/* 8006FE84 */ void setDefault();
@@ -18,10 +62,10 @@ public:
/* 8006FF38 */ void Pause();
/* 8006FFF8 */ void Remove();
static dVibration_pattern const MS_patt[11];
static dVibration_pattern const CS_patt[11];
static dVibration_pattern const MQ_patt[10];
static dVibration_pattern const CQ_patt[10];
static const vib_pattern MS_patt[VIBMODE_S_MAX];
static const vib_pattern CS_patt[VIBMODE_S_MAX];
static const vib_pattern MQ_patt[VIBMODE_Q_MAX];
static const vib_pattern CQ_patt[VIBMODE_Q_MAX];
private:
class {
@@ -29,31 +73,30 @@ private:
class {
public:
/* 0x00 */ u32 field_0x0;
/* 0x04 */ s32 field_0x4;
/* 0x08 */ s32 field_0x8;
/* 0x0C */ s32 field_0xc;
/* 0x10 */ s32 field_0x10;
/* 0x14 */ s32 field_0x14;
/* 0x18 */ cXyz field_0x18;
/* 0x24 */ s32 field_0x24;
/* 0x04 */ int mVibMode;
/* 0x08 */ u32 mPattern;
/* 0x0C */ s32 mLength;
/* 0x10 */ s32 mRounds;
/* 0x14 */ s32 mFlags;
/* 0x18 */ cXyz mPos;
/* 0x24 */ s32 mFrame;
} mShock, mQuake;
} /* 0x00 */ field_0x0;
/* 0x50 */ u32 field_0x50;
/* 0x54 */ int field_0x54;
/* 0x58 */ s32 field_0x58;
/* 0x5C */ s32 field_0x5c;
/* 0x60 */ s32 field_0x60;
/* 0x64 */ s32 field_0x64;
/* 0x68 */ s32 field_0x68;
/* 0x6C */ u32 field_0x6c;
/* 0x70 */ s32 field_0x70;
/* 0x74 */ u32 field_0x74;
/* 0x78 */ u32 field_0x78;
/* 0x7C */ s32 field_0x7c;
/* 0x80 */ s32 field_0x80;
/* 0x84 */ s32 field_0x84;
/* 0x88 */ s32 field_0x88;
/* 0x8C */ s32 field_0x8c;
} /* 0x00 */ mCamera;
class {
public:
class {
public:
/* 0x00 */ u32 field_0x0;
/* 0x04 */ int mVibMode;
/* 0x08 */ u32 mPattern;
/* 0x0C */ s32 mLength;
/* 0x10 */ s32 mRounds;
/* 0x14 */ s32 mFrame;
/* 0x18 */ s32 mStopFrame;
} mShock, mQuake;
} /* 0x50 */ mMotor;
/* 0x88 */ s32 mFrame;
/* 0x8C */ s32 mMode;
}; // Size: 0x90
#endif /* D_D_VIBRATION_H */
include/m_Do/m_Do_controller_pad.h
+25 -25
View File
@@ -20,32 +20,32 @@ public:
static u32 getTrig(u32 pad) { return getCpadInfo(pad).mPressedButtonFlags; }
static u32 getTrigLockL(u32 pad) { return getCpadInfo(pad).mTrigLockL; }
static u32 getTrigLockR(u32 pad) { return getCpadInfo(pad).mTrigLockR; }
static u32 getTrigUp(u32 pad) { return getTrig(pad) & CButton::DPAD_UP; }
static u32 getTrigDown(u32 pad) { return getTrig(pad) & CButton::DPAD_DOWN; }
static u32 getTrigLeft(u32 pad) { return getTrig(pad) & CButton::DPAD_LEFT; }
static u32 getTrigRight(u32 pad) { return getTrig(pad) & CButton::DPAD_RIGHT; }
static u32 getTrigL(u32 pad) { return getTrig(pad) & CButton::L; }
static u32 getTrigR(u32 pad) { return getTrig(pad) & CButton::R; }
static u32 getTrigA(u32 pad) { return getTrig(pad) & CButton::A; }
static u32 getTrigB(u32 pad) { return getTrig(pad) & CButton::B; }
static u32 getTrigZ(u32 pad) { return getTrig(pad) & CButton::Z; }
static u32 getTrigY(u32 pad) { return getTrig(pad) & CButton::Y; }
static u32 getTrigX(u32 pad) { return getTrig(pad) & CButton::X; }
static u32 getTrigStart(u32 pad) { return getTrig(pad) & CButton::START; }
static u32 getTrigUp(u32 pad) { return getTrig(pad) & PAD_BUTTON_UP; }
static u32 getTrigDown(u32 pad) { return getTrig(pad) & PAD_BUTTON_DOWN; }
static u32 getTrigLeft(u32 pad) { return getTrig(pad) & PAD_BUTTON_LEFT; }
static u32 getTrigRight(u32 pad) { return getTrig(pad) & PAD_BUTTON_RIGHT; }
static u32 getTrigL(u32 pad) { return getTrig(pad) & PAD_TRIGGER_L; }
static u32 getTrigR(u32 pad) { return getTrig(pad) & PAD_TRIGGER_R; }
static u32 getTrigA(u32 pad) { return getTrig(pad) & PAD_BUTTON_A; }
static u32 getTrigB(u32 pad) { return getTrig(pad) & PAD_BUTTON_B; }
static u32 getTrigZ(u32 pad) { return getTrig(pad) & PAD_TRIGGER_Z; }
static u32 getTrigY(u32 pad) { return getTrig(pad) & PAD_BUTTON_Y; }
static u32 getTrigX(u32 pad) { return getTrig(pad) & PAD_BUTTON_X; }
static u32 getTrigStart(u32 pad) { return getTrig(pad) & PAD_BUTTON_START; }
static u32 getHold(u32 pad) { return getCpadInfo(pad).mButtonFlags; }
static u32 getHoldLockL(u32 pad) { return getCpadInfo(pad).mHoldLockL; }
static u32 getHoldLockR(u32 pad) { return getCpadInfo(pad).mHoldLockR; }
static u32 getHoldUp(u32 pad) { return getHold(pad) & CButton::DPAD_UP; }
static u32 getHoldDown(u32 pad) { return getHold(pad) & CButton::DPAD_DOWN; }
static u32 getHoldLeft(u32 pad) { return getHold(pad) & CButton::DPAD_LEFT; }
static u32 getHoldRight(u32 pad) { return getHold(pad) & CButton::DPAD_RIGHT; }
static u32 getHoldL(u32 pad) { return getHold(pad) & CButton::L; }
static u32 getHoldR(u32 pad) { return getHold(pad) & CButton::R; }
static u32 getHoldA(u32 pad) { return getHold(pad) & CButton::A; }
static u32 getHoldB(u32 pad) { return getHold(pad) & CButton::B; }
static u32 getHoldZ(u32 pad) { return getHold(pad) & CButton::Z; }
static u32 getHoldY(u32 pad) { return getHold(pad) & CButton::Y; }
static u32 getHoldX(u32 pad) { return getHold(pad) & CButton::X; }
static u32 getHoldUp(u32 pad) { return getHold(pad) & PAD_BUTTON_UP; }
static u32 getHoldDown(u32 pad) { return getHold(pad) & PAD_BUTTON_DOWN; }
static u32 getHoldLeft(u32 pad) { return getHold(pad) & PAD_BUTTON_LEFT; }
static u32 getHoldRight(u32 pad) { return getHold(pad) & PAD_BUTTON_RIGHT; }
static u32 getHoldL(u32 pad) { return getHold(pad) & PAD_TRIGGER_L; }
static u32 getHoldR(u32 pad) { return getHold(pad) & PAD_TRIGGER_R; }
static u32 getHoldA(u32 pad) { return getHold(pad) & PAD_BUTTON_A; }
static u32 getHoldB(u32 pad) { return getHold(pad) & PAD_BUTTON_B; }
static u32 getHoldZ(u32 pad) { return getHold(pad) & PAD_TRIGGER_Z; }
static u32 getHoldY(u32 pad) { return getHold(pad) & PAD_BUTTON_Y; }
static u32 getHoldX(u32 pad) { return getHold(pad) & PAD_BUTTON_X; }
static f32 getStickX(u32 pad) { return getCpadInfo(pad).mMainStickPosX; }
static f32 getStickY(u32 pad) { return getCpadInfo(pad).mMainStickPosY; }
static f32 getStickX3D(u32 pad) { return getCpadInfo(pad).mMainStickPosX; }
@@ -60,8 +60,8 @@ public:
static f32 getAnalogR(u32 pad) { return getCpadInfo(pad).mTriggerRight; }
static f32 getAnalogL(u32 pad) { return getCpadInfo(pad).mTriggerLeft; }
static BOOL isConnect(u32 pad) { return JUTGamePad::getPortStatus(pad) == 0; }
static void startMotorWave(u32 pad, void* param_2, JUTGamePad::CRumble::ERumble param_3, u32 param_4) {
m_gamePad[pad]->startMotorWave(param_2, param_3, param_4);
static void startMotorWave(u32 pad, void* data, JUTGamePad::CRumble::ERumble rumble, u32 length) {
m_gamePad[pad]->startMotorWave(data, rumble, length);
}
static void stopMotor(u32 pad) { m_gamePad[pad]->stopMotor(); }
static void stopMotorWave(u32 pad) { m_gamePad[pad]->stopMotorWave(); }
src/JSystem/JUtility/JUTException.cpp
+5 -5
View File
@@ -635,10 +635,10 @@ bool JUTException::readPad(u32* out_trigger, u32* out_button) {
} while (ms < 0x32);
if (mGamePad == (JUTGamePad*)0xffffffff) {
JUTGamePad gamePad0(JUTGamePad::Port_1);
JUTGamePad gamePad1(JUTGamePad::Port_2);
JUTGamePad gamePad2(JUTGamePad::Port_3);
JUTGamePad gamePad3(JUTGamePad::Port_4);
JUTGamePad gamePad0(JUTGamePad::EPort1);
JUTGamePad gamePad1(JUTGamePad::EPort2);
JUTGamePad gamePad2(JUTGamePad::EPort3);
JUTGamePad gamePad3(JUTGamePad::EPort4);
JUTGamePad::read();
c3bcnt[0] =
@@ -1150,4 +1150,4 @@ JUTException::~JUTException() {}
/* ##############################################################################################
*/
/* 804508F8-80450900 000378 0008+00 0/0 3/3 0/0 .sdata None */
SECTION_SDATA extern bool sAssertVisible = true;
SECTION_SDATA extern bool sAssertVisible = true;
src/JSystem/JUtility/JUTGamePad.cpp
+180 -307
View File
@@ -1,110 +1,8 @@
//
// Generated By: dol2asm
// Translation Unit: JUTGamePad
//
#include "JSystem/JUtility/JUTGamePad.h"
#include "dol2asm.h"
#include "dolphin/os/OSResetSW.h"
#include "math.h"
#include <math.h>
//
// Forward References:
//
extern "C" void __ct__10JUTGamePadFQ210JUTGamePad8EPadPort();
extern "C" void __dt__10JUTGamePadFv();
extern "C" void initList__10JUTGamePadFv();
extern "C" void init__10JUTGamePadFv();
extern "C" void clear__10JUTGamePadFv();
extern "C" void read__10JUTGamePadFv();
extern "C" void assign__10JUTGamePadFv();
extern "C" void checkResetCallback__10JUTGamePadFx();
extern "C" void update__10JUTGamePadFv();
extern "C" void checkResetSwitch__10JUTGamePadFv();
extern "C" void clearForReset__10JUTGamePadFv();
extern "C" void clear__Q210JUTGamePad7CButtonFv();
extern "C" void update__Q210JUTGamePad7CButtonFPC9PADStatusUl();
extern "C" void clear__Q210JUTGamePad6CStickFv();
extern "C" void
update__Q210JUTGamePad6CStickFScScQ210JUTGamePad10EStickModeQ210JUTGamePad11EWhichStickUl();
extern "C" void getButton__Q210JUTGamePad6CStickFUl();
extern "C" void clear__Q210JUTGamePad7CRumbleFv();
extern "C" void clear__Q210JUTGamePad7CRumbleFP10JUTGamePad();
extern "C" void startMotor__Q210JUTGamePad7CRumbleFi();
extern "C" void stopMotor__Q210JUTGamePad7CRumbleFib();
extern "C" static void getNumBit__FPUci();
extern "C" void update__Q210JUTGamePad7CRumbleFs();
extern "C" void triggerPatternedRumble__Q210JUTGamePad7CRumbleFUl();
extern "C" void startPatternedRumble__Q210JUTGamePad7CRumbleFPvQ310JUTGamePad7CRumble7ERumbleUl();
extern "C" void stopPatternedRumble__Q210JUTGamePad7CRumbleFs();
extern "C" void stopPatternedRumbleAtThePeriod__Q210JUTGamePad7CRumbleFv();
extern "C" void getGamePad__10JUTGamePadFi();
extern "C" void setEnabled__Q210JUTGamePad7CRumbleFUl();
extern "C" void setRepeat__Q210JUTGamePad7CButtonFUlUlUl();
extern "C" void recalibrate__10JUTGamePadFUl();
extern "C" void checkCallback__19JUTGamePadLongPressFiUl();
extern "C" void __sinit_JUTGamePad_cpp();
extern "C" void func_802E1C54(void* _this);
extern "C" void __ct__Q210JUTGamePad6CStickFv();
extern "C" void __ct__Q210JUTGamePad7CButtonFv();
extern "C" void func_802E1D08(void* _this);
extern "C" u8 sChannelMask__Q210JUTGamePad7CRumble[16];
extern "C" u8 mPadList__10JUTGamePad[12];
extern "C" u8 mPadStatus__10JUTGamePad[48];
extern "C" u8 mPadButton__10JUTGamePad[192];
extern "C" u8 mPadMStick__10JUTGamePad[64];
extern "C" u8 mPadSStick__10JUTGamePad[64];
extern "C" u8 sPatternList__19JUTGamePadLongPress[12];
extern "C" u32 sStickMode__10JUTGamePad;
extern "C" u32 sClampMode__10JUTGamePad;
extern "C" f32 sPressPoint__Q210JUTGamePad6CStick;
extern "C" f32 sReleasePoint__Q210JUTGamePad6CStick;
extern "C" u32 sResetPattern__Q210JUTGamePad13C3ButtonReset;
extern "C" u32 sResetMaskPattern__Q210JUTGamePad13C3ButtonReset;
extern "C" u8 mPadAssign__10JUTGamePad[4];
extern "C" u8 sSuppressPadReset__10JUTGamePad[4];
extern "C" u8 sAnalogMode__10JUTGamePad[4];
extern "C" u8 sRumbleSupported__10JUTGamePad[4];
extern "C" u8 mStatus__Q210JUTGamePad7CRumble[4];
extern "C" u8 mEnabled__Q210JUTGamePad7CRumble[4];
extern "C" u8 sCallback__Q210JUTGamePad13C3ButtonReset[4];
extern "C" u8 sCallbackArg__Q210JUTGamePad13C3ButtonReset[4 + 4 /* padding */];
extern "C" u8 sThreshold__Q210JUTGamePad13C3ButtonReset[4];
extern "C" u8 sResetOccurredPort__Q210JUTGamePad13C3ButtonReset[4];
//
// External References:
//
extern "C" void __dl__FPv();
extern "C" void __ct__11JKRDisposerFv();
extern "C" void __dt__11JKRDisposerFv();
extern "C" void __ct__10JSUPtrLinkFPv();
extern "C" void __dt__10JSUPtrLinkFv();
extern "C" void __ct__10JSUPtrListFb();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void _savegpr_22();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_22();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
//
// Declarations:
//
/* ############################################################################################## */
/* 803CC5F0-803CC600 029710 0010+00 3/3 0/0 0/0 .data sChannelMask__Q210JUTGamePad7CRumble */
SECTION_DATA u32 JUTGamePad::CRumble::sChannelMask[4] = {
u32 JUTGamePad::CRumble::sChannelMask[4] = {
PAD_CHAN0_BIT,
PAD_CHAN1_BIT,
PAD_CHAN2_BIT,
@@ -112,7 +10,7 @@ SECTION_DATA u32 JUTGamePad::CRumble::sChannelMask[4] = {
};
/* 803CC600-803CC610 029720 0010+00 2/2 0/0 0/0 .data channel_mask */
SECTION_DATA static u32 channel_mask[4] = {0x80000000, 0x40000000, 0x20000000, 0x10000000};
static u32 channel_mask[4] = {PAD_CHAN0_BIT, PAD_CHAN1_BIT, PAD_CHAN2_BIT, PAD_CHAN3_BIT};
/* 804343E4-804343F0 061104 000C+00 4/6 0/0 0/0 .bss mPadList__10JUTGamePad */
JSUList<JUTGamePad> JUTGamePad::mPadList(false);
@@ -143,7 +41,7 @@ JUTGamePad::JUTGamePad(EPadPort port) : mRumble(this), mLink(this) {
JUTGamePad::~JUTGamePad() {
if (mPortNum >= 0) {
mPadAssign[mPortNum]--;
mPortNum = -1;
mPortNum = EPortInvalid;
}
mPadList.remove(&mLink);
@@ -157,7 +55,6 @@ void JUTGamePad::initList() {
}
}
/* ############################################################################################## */
/* 804514D8-804514DC 0009D8 0004+00 2/2 0/0 0/0 .sbss sSuppressPadReset__10JUTGamePad */
u32 JUTGamePad::sSuppressPadReset;
@@ -165,8 +62,8 @@ u32 JUTGamePad::sSuppressPadReset;
s32 JUTGamePad::sAnalogMode;
/* 802E0898-802E08D0 2DB1D8 0038+00 0/0 1/1 0/0 .text init__10JUTGamePadFv */
s32 JUTGamePad::init() {
PADSetSpec(5);
BOOL JUTGamePad::init() {
PADSetSpec(PAD_SPEC_5);
setAnalogMode(3);
return PADInit();
}
@@ -177,7 +74,6 @@ void JUTGamePad::clear() {
field_0xa8 = 1;
}
/* ############################################################################################## */
/* 804343F0-80434420 061110 0030+00 1/3 1/1 0/0 .bss mPadStatus__10JUTGamePad */
PADStatus JUTGamePad::mPadStatus[4];
@@ -185,59 +81,51 @@ PADStatus JUTGamePad::mPadStatus[4];
JUTGamePad::CButton JUTGamePad::mPadButton[4];
/* 804344E0-80434520 061200 0040+00 0/3 0/0 0/0 .bss mPadMStick__10JUTGamePad */
#pragma push
#pragma force_active on
JUTGamePad::CStick JUTGamePad::mPadMStick[4];
#pragma pop
/* 80434520-80434560 061240 0040+00 0/3 0/0 0/0 .bss mPadSStick__10JUTGamePad */
#pragma push
#pragma force_active on
JUTGamePad::CStick JUTGamePad::mPadSStick[4];
#pragma pop
/* 804508D8-804508DC 000358 0004+00 1/1 0/0 0/0 .sdata sStickMode__10JUTGamePad */
SECTION_SDATA JUTGamePad::EStickMode JUTGamePad::sStickMode = STICK_MODE_1;
JUTGamePad::EStickMode JUTGamePad::sStickMode = EStickMode1;
/* 804508DC-804508E0 00035C 0004+00 2/2 0/0 0/0 .sdata sClampMode__10JUTGamePad */
SECTION_SDATA u32 JUTGamePad::sClampMode = 0x00000001;
int JUTGamePad::sClampMode = EClampStick;
/* 804514E0-804514E4 0009E0 0004+00 1/1 2/2 0/0 .sbss sRumbleSupported__10JUTGamePad */
u32 JUTGamePad::sRumbleSupported;
/* 802E08E4-802E0BBC 2DB224 02D8+00 0/0 2/2 0/0 .text read__10JUTGamePadFv */
#ifdef NONMATCHING
u32 JUTGamePad::read() {
sRumbleSupported = PADRead(mPadStatus);
switch (sClampMode) {
case 1:
case EClampStick:
PADClamp(mPadStatus);
break;
case 2:
case EClampCircle:
PADClampCircle(mPadStatus);
break;
}
u32 mask = 0;
u32 reset_mask = 0;
u32 bittest;
for (int i = 0; i < 4; i++) {
u32 mask_tmp = 0x80000000 >> i;
bittest = PAD_CHAN0_BIT >> i;
if (mPadStatus[i].error == 0) {
u32 m_stick = mPadMStick[i].update(mPadStatus[i].stick_x, mPadStatus[i].stick_y,
sStickMode, WS_MAIN_STICK, mPadButton[i].mButton)
<< 0x18;
u32 s_stick = (mPadSStick[i].update(mPadStatus[i].substick_x, mPadStatus[i].substick_y,
sStickMode, WS_SUB_STICK, mPadButton[i].mButton)
<< 0x10);
m_stick |= s_stick;
mPadButton[i].update(&mPadStatus[i], m_stick);
u32 stick_status;
stick_status = mPadMStick[i].update(mPadStatus[i].stick_x, mPadStatus[i].stick_y, sStickMode, EMainStick, mPadButton[i].mButton) << 0x18;
stick_status |= (mPadSStick[i].update(mPadStatus[i].substick_x, mPadStatus[i].substick_y, sStickMode, ESubStick, mPadButton[i].mButton) << 0x10);
mPadButton[i].update(&mPadStatus[i], stick_status);
} else if (mPadStatus[i].error == -1) {
u32 m_stick = mPadMStick[i].update(0, 0, sStickMode, WS_MAIN_STICK, 0);
u32 s_stick = mPadSStick[i].update(0, 0, sStickMode, WS_SUB_STICK, 0);
mPadMStick[i].update(0, 0, sStickMode, EMainStick, 0);
mPadSStick[i].update(0, 0, sStickMode, ESubStick, 0);
mPadButton[i].update(NULL, 0);
if (!(sSuppressPadReset & mask_tmp)) {
mask |= mask_tmp;
if (!(sSuppressPadReset & bittest)) {
reset_mask |= bittest;
}
} else {
mPadButton[i].mTrigger = 0;
@@ -246,46 +134,40 @@ u32 JUTGamePad::read() {
}
}
JSUListIterator<JUTGamePad> pad(mPadList.getFirst());
for (; pad != mPadList.getEnd(); pad++) {
if (pad->getPadReplay() && pad->getPadReplay()->mActive) {
for (JSUListIterator<JUTGamePad> pad(mPadList.getFirst()); pad != mPadList.getEnd(); pad++) {
if (pad->getPadReplay() != NULL && pad->getPadReplay()->isActive()) {
PADStatus status;
pad->getPadReplay()->unk1(&status);
u32 m_stick = pad->mMainStick.update(status.stick_x, status.stick_y, sStickMode,
WS_MAIN_STICK, pad->mButton.mButton)
<< 0x18;
u32 s_stick = pad->mSubStick.update(status.substick_x, status.substick_y, sStickMode,
WS_SUB_STICK, pad->mButton.mButton)
<< 0x10;
m_stick |= s_stick;
pad->mButton.update(&status, m_stick);
pad->getPadReplay()->getStatus(&status);
u32 stick_status;
stick_status = pad->mMainStick.update(status.stick_x, status.stick_y, sStickMode,
EMainStick, pad->mButton.mButton) << 0x18;
stick_status |= pad->mSubStick.update(status.substick_x, status.substick_y, sStickMode,
ESubStick, pad->mButton.mButton) << 0x10;
pad->mButton.update(&status, stick_status);
} else {
if (pad->mPortNum == -1) {
if (pad->mPortNum == EPortInvalid) {
pad->assign();
}
pad->update();
}
if (pad->getPadRecord() && pad->getPadRecord()->mActive) {
s32 portNum = pad->mPortNum;
if (portNum >= 0 && mPadStatus[portNum].error == 0) {
pad->getPadRecord()->unk2();
if (pad->getPadRecord() != NULL && pad->getPadRecord()->isActive()) {
int port = pad->mPortNum;
if (port >= 0 && mPadStatus[port].error == 0) {
pad->getPadRecord()->write(&mPadStatus[port]);
}
}
}
if (mask != 0) {
PADReset(mask);
if (reset_mask != 0) {
PADReset(reset_mask);
}
checkResetSwitch();
return sRumbleSupported;
}
#else
u32 JUTGamePad::read() {
// NONMATCHING
}
#endif
/* 802E0BBC-802E0C6C 2DB4FC 00B0+00 1/1 0/0 0/0 .text assign__10JUTGamePadFv */
void JUTGamePad::assign() {
@@ -293,14 +175,13 @@ void JUTGamePad::assign() {
if (mPadStatus[i].error == 0 && mPadAssign[i] == 0) {
mPortNum = i;
mPadAssign[i] = 1;
mPadButton[i].setRepeat(mButton.field_0x24, mButton.field_0x28, mButton.field_0x2c);
mPadButton[i].setRepeat(mButton.mRepeatMask, mButton.mRepeatDelay, mButton.mRepeatRate);
mRumble.clear(this);
return;
break;
}
}
}
/* ############################################################################################## */
/* 804514E4-804514E8 0009E4 0004+00 5/5 0/0 0/0 .sbss mStatus__Q210JUTGamePad7CRumble */
bool JUTGamePad::CRumble::mStatus[4];
@@ -315,12 +196,12 @@ callbackFn JUTGamePad::C3ButtonReset::sCallback;
void* JUTGamePad::C3ButtonReset::sCallbackArg;
/* 804514F8-80451500 0009F8 0008+00 2/2 0/0 0/0 .sbss sThreshold__Q210JUTGamePad13C3ButtonReset */
OSTime JUTGamePad::C3ButtonReset::sThreshold = (OSTime)((OS_BUS_CLOCK / 4) / 60) * 30;
OSTime JUTGamePad::C3ButtonReset::sThreshold = (OSTime)(OS_TIMER_CLOCK / 60) * 30;
/* 80451500-80451504 -00001 0004+00 3/3 6/6 0/0 .sbss None */
/* 80451500 0001+00 data_80451500 None */
/* 80451501 0003+00 data_80451501 None */
bool JUTGamePad::C3ButtonReset::sResetSwitchPushing;
/* 80451501 0003+00 data_80451501 None */
bool JUTGamePad::C3ButtonReset::sResetOccurred;
/* 80451504-80451508 000A04 0004+00 2/2 0/0 0/0 .sbss
@@ -330,41 +211,34 @@ s32 JUTGamePad::C3ButtonReset::sResetOccurredPort;
/* 802E0C6C-802E0CD8 2DB5AC 006C+00 1/1 1/1 0/0 .text checkResetCallback__10JUTGamePadFx
*/
void JUTGamePad::checkResetCallback(OSTime holdTime) {
if (holdTime < JUTGamePad::C3ButtonReset::sThreshold) {
return;
}
if (holdTime >= JUTGamePad::C3ButtonReset::sThreshold) {
JUTGamePad::C3ButtonReset::sResetOccurred = true;
JUTGamePad::C3ButtonReset::sResetOccurredPort = mPortNum;
JUTGamePad::C3ButtonReset::sResetOccurred = true;
JUTGamePad::C3ButtonReset::sResetOccurredPort = mPortNum;
if (JUTGamePad::C3ButtonReset::sCallback != NULL) {
JUTGamePad::C3ButtonReset::sCallback(mPortNum, JUTGamePad::C3ButtonReset::sCallbackArg);
if (JUTGamePad::C3ButtonReset::sCallback != NULL) {
JUTGamePad::C3ButtonReset::sCallback(mPortNum, JUTGamePad::C3ButtonReset::sCallbackArg);
}
}
}
/* 8043456C-80434578 06128C 000C+00 1/2 0/0 0/0 .bss sPatternList__19JUTGamePadLongPress
*/
JSUList<JUTGamePadLongPress> JUTGamePadLongPress::sPatternList(false);
/* 804508E0-804508E4 000360 0004+00 1/1 0/0 0/0 .sdata sPressPoint__Q210JUTGamePad6CStick
*/
SECTION_SDATA f32 JUTGamePad::CStick::sPressPoint = 0.5f;
f32 JUTGamePad::CStick::sPressPoint = 0.5f;
/* 804508E4-804508E8 000364 0004+00 1/1 0/0 0/0 .sdata sReleasePoint__Q210JUTGamePad6CStick */
SECTION_SDATA f32 JUTGamePad::CStick::sReleasePoint = 0.25f;
f32 JUTGamePad::CStick::sReleasePoint = 0.25f;
/* 804508E8-804508EC 000368 0004+00 1/1 0/0 0/0 .sdata
* sResetPattern__Q210JUTGamePad13C3ButtonReset */
SECTION_SDATA u32 JUTGamePad::C3ButtonReset::sResetPattern = 0x00001600;
u32 JUTGamePad::C3ButtonReset::sResetPattern = PAD_BUTTON_START | PAD_BUTTON_X | PAD_BUTTON_B;
/* 804508EC-804508F0 00036C 0004+00 1/1 0/0 0/0 .sdata
* sResetMaskPattern__Q210JUTGamePad13C3ButtonReset */
SECTION_SDATA u32 JUTGamePad::C3ButtonReset::sResetMaskPattern = 0x0000FFFF;
u32 JUTGamePad::C3ButtonReset::sResetMaskPattern = 0x0000FFFF;
/* 802E0CD8-802E0FA4 2DB618 02CC+00 2/2 0/0 0/0 .text update__10JUTGamePadFv */
#ifdef NONMATCHING
void JUTGamePad::update() {
if (mPortNum != -1) {
if (mPortNum != EPortInvalid) {
if (mPortNum >= 0 && mPortNum < 4) {
mButton = mPadButton[mPortNum];
mMainStick = mPadMStick[mPortNum];
@@ -372,32 +246,31 @@ void JUTGamePad::update() {
mErrorStatus = mPadStatus[mPortNum].error;
}
if (field_0xa8 == 0 ||
(mButton.mButton & C3ButtonReset::sResetMaskPattern) != C3ButtonReset::sResetPattern)
{
if (field_0xa8 == 0 || C3ButtonReset::sResetPattern != (mButton.mButton & C3ButtonReset::sResetMaskPattern)) {
mButtonReset.mReset = false;
} else if (!JUTGamePad::C3ButtonReset::sResetOccurred) {
if (mButtonReset.mReset == true) {
checkResetCallback(OSGetTime() - mResetTime);
OSTime hold_time = OSGetTime() - mResetHoldStartTime;
checkResetCallback(hold_time);
} else {
mButtonReset.mReset = true;
mResetTime = OSGetTime();
mResetHoldStartTime = OSGetTime();
}
}
JSUListIterator<JUTGamePadLongPress> pad(JUTGamePadLongPress::sPatternList.getFirst());
for (; pad != JUTGamePadLongPress::sPatternList.getEnd(); pad++) {
if (pad->mValid) {
for (JSUListIterator<JUTGamePadLongPress> pad(JUTGamePadLongPress::sPatternList.getFirst()); pad != JUTGamePadLongPress::sPatternList.getEnd(); ++pad) {
if (pad->isValid()) {
if (mPortNum >= 0 && mPortNum < 4) {
if ((mButton.mButton & pad->getMaskPattern()) == pad->getPattern()) {
if (pad->field_0x20[mPortNum] == true) {
pad->checkCallback(mPortNum, OSGetTime() - pad->mTimer[mPortNum]);
if (pad->mLongPressStatus[mPortNum] == true) {
OSTime hold_time = OSGetTime() - pad->mStartHoldTime[mPortNum];
pad->checkCallback(mPortNum, hold_time);
} else {
pad->field_0x20[mPortNum] = true;
pad->mTimer[mPortNum] = OSGetTime();
pad->mLongPressStatus[mPortNum] = true;
pad->mStartHoldTime[mPortNum] = OSGetTime();
}
} else {
pad->field_0x20[mPortNum] = false;
pad->mLongPressStatus[mPortNum] = false;
}
}
}
@@ -408,11 +281,10 @@ void JUTGamePad::update() {
}
}
}
#else
void JUTGamePad::update() {
// NONMATCHING
}
#endif
/* 8043456C-80434578 06128C 000C+00 1/2 0/0 0/0 .bss sPatternList__19JUTGamePadLongPress
*/
JSUList<JUTGamePadLongPress> JUTGamePadLongPress::sPatternList(false);
/* 802E0FA4-802E1024 2DB8E4 0080+00 1/1 0/0 0/0 .text checkResetSwitch__10JUTGamePadFv */
void JUTGamePad::checkResetSwitch() {
@@ -422,10 +294,10 @@ void JUTGamePad::checkResetSwitch() {
} else {
if (C3ButtonReset::sResetSwitchPushing == true) {
C3ButtonReset::sResetOccurred = true;
C3ButtonReset::sResetOccurredPort = -1;
C3ButtonReset::sResetOccurredPort = EPortInvalid;
if (C3ButtonReset::sCallback != NULL) {
C3ButtonReset::sCallback(-1, C3ButtonReset::sCallbackArg);
C3ButtonReset::sCallback(EPortInvalid, C3ButtonReset::sCallbackArg);
}
}
C3ButtonReset::sResetSwitchPushing = false;
@@ -449,16 +321,16 @@ void JUTGamePad::CButton::clear() {
mAnalogB = 0;
mAnalogL = 0;
mAnalogR = 0;
field_0x1c = 0;
field_0x20 = 0;
field_0x24 = 0;
field_0x28 = 0;
field_0x2c = 0;
mRepeatCount = 0;
mRepeatStart = 0;
mRepeatMask = 0;
mRepeatDelay = 0;
mRepeatRate = 0;
}
/* 802E108C-802E121C 2DB9CC 0190+00 1/1 0/0 0/0 .text
* update__Q210JUTGamePad7CButtonFPC9PADStatusUl */
void JUTGamePad::CButton::update(PADStatus const* padStatus, u32 stickStatus) {
void JUTGamePad::CButton::update(const PADStatus* padStatus, u32 stickStatus) {
u32 buttons;
if (padStatus != NULL) {
buttons = padStatus->button;
@@ -469,32 +341,32 @@ void JUTGamePad::CButton::update(PADStatus const* padStatus, u32 stickStatus) {
buttons = stickStatus | buttons;
mRepeat = 0;
if (field_0x28 != 0 && field_0x24 != 0) {
u32 repeatButton = buttons & field_0x24;
if (mRepeatDelay != 0 && mRepeatMask != 0) {
u32 repeatButton = buttons & mRepeatMask;
mRepeat = 0;
if (repeatButton == 0) {
field_0x20 = 0;
field_0x1c = 0;
} else if (field_0x20 == repeatButton) {
field_0x1c++;
mRepeatStart = 0;
mRepeatCount = 0;
} else if (mRepeatStart == repeatButton) {
mRepeatCount++;
if (field_0x1c == field_0x28 ||
(field_0x1c > field_0x28 && (field_0x1c - field_0x28) % field_0x2c == 0))
if (mRepeatCount == mRepeatDelay ||
(mRepeatCount > mRepeatDelay && (mRepeatCount - mRepeatDelay) % mRepeatRate == 0))
{
mRepeat = repeatButton;
}
} else {
mRepeat = repeatButton & (field_0x20 ^ 0xFFFFFFFF);
field_0x20 = repeatButton;
field_0x1c = 0;
mRepeat = repeatButton & (mRepeatStart ^ 0xFFFFFFFF);
mRepeatStart = repeatButton;
mRepeatCount = 0;
}
}
mTrigger = buttons & (buttons ^ mButton);
mRelease = mButton & (buttons ^ mButton);
mButton = buttons;
mRepeat |= (field_0x24 ^ 0xFFFFFFFF) & mTrigger;
mRepeat |= (mRepeatMask ^ 0xFFFFFFFF) & mTrigger;
if (padStatus != NULL) {
mAnalogA = padStatus->analog_a;
@@ -522,29 +394,29 @@ void JUTGamePad::CStick::clear() {
/* 802E1238-802E1500 2DBB78 02C8+00 1/1 0/0 0/0 .text
* update__Q210JUTGamePad6CStickFScScQ210JUTGamePad10EStickModeQ210JUTGamePad11EWhichStickUl */
u32 JUTGamePad::CStick::update(s8 x_val, s8 y_val, JUTGamePad::EStickMode mode,
u32 JUTGamePad::CStick::update(s8 x, s8 y, JUTGamePad::EStickMode mode,
JUTGamePad::EWhichStick stick, u32 buttons) {
s32 clamp;
switch (sClampMode) {
case 1:
clamp = stick == WS_MAIN_STICK ? 54 : 42;
case EClampStick:
clamp = stick == EMainStick ? 54 : 42;
break;
case 2:
clamp = stick == WS_MAIN_STICK ? 38 : 29;
case EClampCircle:
clamp = stick == EMainStick ? 38 : 29;
break;
default:
clamp = stick == WS_MAIN_STICK ? 69 : 57;
clamp = stick == EMainStick ? 69 : 57;
break;
}
field_0xe = x_val;
field_0xf = y_val;
mPosX = (f32)x_val / (f32)clamp;
mPosY = (f32)y_val / (f32)clamp;
mRawX = x;
mRawY = y;
mPosX = (f32)x / (f32)clamp;
mPosY = (f32)y / (f32)clamp;
mValue = sqrtf((mPosX * mPosX) + (mPosY * mPosY));
if (mValue > 1.0f) {
if (mode == STICK_MODE_1) {
if (mode == EStickMode1) {
mPosX /= mValue;
mPosY /= mValue;
}
@@ -559,12 +431,12 @@ u32 JUTGamePad::CStick::update(s8 x_val, s8 y_val, JUTGamePad::EStickMode mode,
mAngle = -0x4000;
}
} else {
mAngle = 10430.379f * atan2f(mPosX, -mPosY);
mAngle = (0x8000 / 3.1415926f) * atan2f(mPosX, -mPosY);
}
}
u32 buttonType = stick == WS_MAIN_STICK ? 0x18 : 0x10;
return getButton(buttons >> buttonType);
u32 button_shift = stick == EMainStick ? 0x18 : 0x10;
return getButton(buttons >> button_shift);
}
/* 802E1500-802E15B4 2DBE40 00B4+00 1/1 0/0 0/0 .text getButton__Q210JUTGamePad6CStickFUl
@@ -573,19 +445,19 @@ u32 JUTGamePad::CStick::getButton(u32 buttons) {
u32 button = buttons & 0xF;
if (-sReleasePoint < mPosX && mPosX < sReleasePoint) {
button = button & 0xFFFFFFFC;
button = button & ~0x3;
} else if (mPosX <= -sPressPoint) {
button = (button & 0xFFFFFFFD) | 1;
button = (button & ~0x2) | 1;
} else if (mPosX >= sPressPoint) {
button = (button & 0xFFFFFFFE) | 2;
button = (button & ~0x1) | 2;
}
if (-sReleasePoint < mPosY && mPosY < sReleasePoint) {
button = button & 0xFFFFFFF3;
button = button & ~0xC;
} else if (mPosY <= -sPressPoint) {
button = (button & 0xFFFFFFF7) | 4;
button = (button & ~0x8) | 4;
} else if (mPosY >= sPressPoint) {
button = (button & 0xFFFFFFFB) | 8;
button = (button & ~0x4) | 8;
}
return button;
@@ -593,10 +465,10 @@ u32 JUTGamePad::CStick::getButton(u32 buttons) {
/* 802E15B4-802E15D8 2DBEF4 0024+00 1/1 0/0 0/0 .text clear__Q210JUTGamePad7CRumbleFv */
void JUTGamePad::CRumble::clear() {
field_0x0 = 0;
field_0x4 = 0;
field_0x8 = 0;
field_0xc = 0;
mFrame = 0;
mLength = 0;
mPattern = NULL;
mFrameCount = 0;
field_0x10 = 0;
mEnabled = (PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT);
}
@@ -612,98 +484,98 @@ void JUTGamePad::CRumble::clear(JUTGamePad* pad) {
}
/* 802E1634-802E168C 2DBF74 0058+00 1/1 0/0 0/0 .text startMotor__Q210JUTGamePad7CRumbleFi */
void JUTGamePad::CRumble::startMotor(int portNo) {
if (isEnabledPort(portNo)) {
PADControlMotor(portNo, 1);
mStatus[portNo] = true;
void JUTGamePad::CRumble::startMotor(int port) {
if (isEnabledPort(port)) {
PADControlMotor(port, PAD_MOTOR_RUMBLE);
mStatus[port] = true;
}
}
/* 802E168C-802E16F8 2DBFCC 006C+00 4/4 3/3 0/0 .text stopMotor__Q210JUTGamePad7CRumbleFib */
void JUTGamePad::CRumble::stopMotor(int portNo, bool stop) {
if (isEnabledPort(portNo)) {
u8 command = stop ? 2 : 0;
PADControlMotor(portNo, command);
mStatus[portNo] = false;
void JUTGamePad::CRumble::stopMotor(int port, bool hard_stop) {
if (isEnabledPort(port)) {
u8 command = hard_stop ? PAD_MOTOR_STOP_HARD : PAD_MOTOR_STOP;
PADControlMotor(port, command);
mStatus[port] = false;
}
}
/* 802E16F8-802E1720 2DC038 0028+00 1/1 0/0 0/0 .text getNumBit__FPUci */
static bool getNumBit(u8* arr, int bitNo) {
u8 bit = (arr[bitNo >> 3] & (0x80 >> (bitNo & 7)));
static bool getNumBit(u8* pattern, int index) {
u8 bit = pattern[index >> 3] & (0x80 >> (index & 7));
return bit != 0;
}
/* 802E1720-802E18A4 2DC060 0184+00 1/1 0/0 0/0 .text update__Q210JUTGamePad7CRumbleFs */
void JUTGamePad::CRumble::update(s16 portNo) {
if (isEnabledPort(portNo) == false) {
field_0x0 = 0;
field_0x4 = 0;
field_0x8 = NULL;
field_0xc = 0;
void JUTGamePad::CRumble::update(s16 port) {
if (isEnabledPort(port) == false) {
mFrame = 0;
mLength = 0;
mPattern = NULL;
mFrameCount = 0;
field_0x10 = NULL;
}
if (field_0x4 == 0) {
if (mLength == 0) {
return;
}
if (field_0x0 >= field_0x4) {
stopMotor(portNo, true);
field_0x4 = 0;
} else if (field_0xc == 0) {
if (mStatus[portNo] == 0) {
startMotor(portNo);
if (mFrame >= mLength) {
stopMotorHard(port);
mLength = 0;
} else if (mFrameCount == 0) {
if (mStatus[port] == 0) {
startMotor(port);
}
return;
} else {
u32 temp = (field_0x0 / field_0xc);
bool numBit = getNumBit(field_0x8, field_0x0 - temp * field_0xc);
u8 status = mStatus[portNo] != false;
if (numBit && !status) {
startMotor(portNo);
} else if (!numBit) {
bool bit = false;
bool enabled = getNumBit(mPattern, mFrame % mFrameCount);
u8 status = mStatus[port] != false;
if (enabled && !status) {
startMotor(port);
} else if (!enabled) {
bool hard_stop = false;
if (field_0x10) {
u32 temp = (field_0x0 / field_0xc);
bit = getNumBit(field_0x10, field_0x0 - temp * field_0xc);
hard_stop = getNumBit(field_0x10, mFrame % mFrameCount);
}
if (status) {
stopMotor(portNo, bit);
} else if (bit) {
stopMotor(portNo, 1);
stopMotor(port, hard_stop);
} else if (hard_stop) {
stopMotorHard(port);
}
}
}
field_0x0++;
mFrame++;
}
/* 802E18A4-802E18CC 2DC1E4 0028+00 1/1 0/0 0/0 .text
* triggerPatternedRumble__Q210JUTGamePad7CRumbleFUl */
void JUTGamePad::CRumble::triggerPatternedRumble(u32 param_0) {
if (field_0x8 != NULL && field_0xc != 0) {
field_0x4 = param_0;
field_0x0 = 0;
void JUTGamePad::CRumble::triggerPatternedRumble(u32 length) {
if (mPattern != NULL && mFrameCount != 0) {
mLength = length;
mFrame = 0;
}
}
/* 802E18CC-802E1948 2DC20C 007C+00 0/0 2/2 0/0 .text
* startPatternedRumble__Q210JUTGamePad7CRumbleFPvQ310JUTGamePad7CRumble7ERumbleUl */
void JUTGamePad::CRumble::startPatternedRumble(void* param_0, JUTGamePad::CRumble::ERumble param_1,
u32 param_2) {
field_0xc = ((*(u8*)param_0) << 8) + *((u8*)param_0 + 1);
field_0x8 = (u8*)param_0 + 2;
switch (param_1) {
void JUTGamePad::CRumble::startPatternedRumble(void* data, JUTGamePad::CRumble::ERumble rumble,
u32 length) {
mFrameCount = ((*(u8*)data) << 8) + *((u8*)data + 1);
mPattern = (u8*)data + 2;
switch (rumble) {
case JUTGamePad::CRumble::VAL_0:
triggerPatternedRumble(field_0xc);
triggerPatternedRumble(mFrameCount);
break;
case JUTGamePad::CRumble::VAL_1:
triggerPatternedRumble(-1);
break;
case JUTGamePad::CRumble::VAL_2:
triggerPatternedRumble(param_2);
triggerPatternedRumble(length);
break;
}
}
@@ -711,22 +583,22 @@ void JUTGamePad::CRumble::startPatternedRumble(void* param_0, JUTGamePad::CRumbl
/* 802E1948-802E1978 2DC288 0030+00 1/1 3/3 0/0 .text
* stopPatternedRumble__Q210JUTGamePad7CRumbleFs */
void JUTGamePad::CRumble::stopPatternedRumble(s16 port) {
field_0x4 = 0;
stopMotor(port, true);
mLength = 0;
stopMotorHard(port);
}
/* 802E1978-802E199C 2DC2B8 0024+00 0/0 1/1 0/0 .text
* stopPatternedRumbleAtThePeriod__Q210JUTGamePad7CRumbleFv */
void JUTGamePad::CRumble::stopPatternedRumbleAtThePeriod() {
field_0x4 = (field_0x0 + field_0xc - 1) % field_0xc;
mLength = (mFrame + mFrameCount - 1) % mFrameCount;
}
/* 802E199C-802E19D8 2DC2DC 003C+00 1/1 1/1 0/0 .text getGamePad__10JUTGamePadFi */
JUTGamePad* JUTGamePad::getGamePad(int padNo) {
JUTGamePad* JUTGamePad::getGamePad(int port) {
JSUListIterator<JUTGamePad> pad(mPadList.getFirst());
for (; pad != mPadList.getEnd(); pad++) {
if (padNo == pad->mPortNum) {
if (port == pad->mPortNum) {
return pad.getObject();
}
}
@@ -748,16 +620,17 @@ void JUTGamePad::CRumble::setEnabled(u32 mask) {
}
}
}
mEnabled = (mask & (PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT));
}
/* 802E1A7C-802E1A98 2DC3BC 001C+00 1/1 0/0 0/0 .text setRepeat__Q210JUTGamePad7CButtonFUlUlUl */
void JUTGamePad::CButton::setRepeat(u32 param_0, u32 param_1, u32 param_2) {
field_0x20 = 0;
field_0x1c = 0;
field_0x24 = param_0;
field_0x28 = param_1;
field_0x2c = param_2;
void JUTGamePad::CButton::setRepeat(u32 mask, u32 delay, u32 rate) {
mRepeatStart = 0;
mRepeatCount = 0;
mRepeatMask = mask;
mRepeatDelay = delay;
mRepeatRate = rate;
}
/* 802E1A98-802E1AFC 2DC3D8 0064+00 1/1 0/0 0/0 .text recalibrate__10JUTGamePadFUl */
@@ -772,8 +645,8 @@ bool JUTGamePad::recalibrate(u32 mask) {
}
/* 802E1AFC-802E1B60 2DC43C 0064+00 1/1 0/0 0/0 .text checkCallback__19JUTGamePadLongPressFiUl */
void JUTGamePadLongPress::checkCallback(int port, u32 timer) {
if (port >= 0 && timer >= field_0x1c) {
void JUTGamePadLongPress::checkCallback(int port, u32 hold_time) {
if (port >= 0 && hold_time >= mThreshold) {
field_0x11 = true;
field_0x48[port] = true;
@@ -781,4 +654,4 @@ void JUTGamePadLongPress::checkCallback(int port, u32 timer) {
mCallback(port, this, field_0x50);
}
}
}
}
src/SSystem/SComponent/c_API_controller_pad.cpp
+2 -2
View File
@@ -13,5 +13,5 @@ void cAPICPad_recalibrate() {
/* 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) & (CButton::A | CButton::B | CButton::START);
}
return mDoCPd_c::getTrig(portNo) & (PAD_BUTTON_A | PAD_BUTTON_B | PAD_BUTTON_START);
}
src/d/d_menu_window.cpp
+352 -1243
View File
File diff suppressed because it is too large Load Diff
src/d/d_s_logo.cpp
+3 -3
View File
@@ -300,9 +300,9 @@ void dScnLogo_c::warningDispDraw() {
}
if (mTimer == 0 || mDoCPd_c::getTrig(PAD_1) &
(CButton::A | CButton::B | CButton::X | CButton::Y | CButton::START |
CButton::Z | CButton::L | CButton::R | CButton::DPAD_LEFT |
CButton::DPAD_RIGHT | CButton::DPAD_DOWN | CButton::DPAD_UP))
(PAD_BUTTON_A | PAD_BUTTON_B | PAD_BUTTON_X | PAD_BUTTON_Y | PAD_BUTTON_START |
PAD_TRIGGER_Z | PAD_TRIGGER_L | PAD_TRIGGER_R | PAD_BUTTON_LEFT |
PAD_BUTTON_RIGHT | PAD_BUTTON_DOWN | PAD_BUTTON_UP))
{
mExecCommand = EXEC_WARNING_OUT;
mTimer = 30;
src/d/d_vib_pattern.cpp
+51 -58
View File
@@ -1,66 +1,59 @@
//
// Generated By: dol2asm
// Translation Unit: d/d_vib_pattern
//
#include "d/d_vib_pattern.h"
#include "d/d_vibration.h"
/* ############################################################################################## */
/* 8037A620-8037A678 006C80 0058+00 0/0 1/1 0/0 .rodata MS_patt__12dVibration_c */
const dVibration_pattern dVibration_c::MS_patt[11] = {
{0x0000, 0x0000, 0x00000000},
{0x0000, 0x0003, 0xC0000000},
{0x0000, 0x0004, 0xE0000000},
{0x0000, 0x0006, 0xE8000000},
{0x0000, 0x0007, 0xEC000000},
{0x0000, 0x0008, 0xF6000000},
{0x0000, 0x0009, 0xFB000000},
{0x0000, 0x000A, 0xF6800000},
{0x0000, 0x000B, 0xFB400000},
{0x0000, 0x0008, 0xC2000000},
{0x0000, 0x0002, 0xC0000000},
// Motor Shock patterns
const vib_pattern dVibration_c::MS_patt[VIBMODE_S_MAX] = {
/* VIBMODE_S_CUSTOM */ {0, 0, 0x00000000},
/* VIBMODE_S_POWER1 */ {0, 3, 0xC0000000},
/* VIBMODE_S_POWER2 */ {0, 4, 0xE0000000},
/* VIBMODE_S_POWER3 */ {0, 6, 0xE8000000},
/* VIBMODE_S_POWER4 */ {0, 7, 0xEC000000},
/* VIBMODE_S_POWER5 */ {0, 8, 0xF6000000},
/* VIBMODE_S_POWER6 */ {0, 9, 0xFB000000},
/* VIBMODE_S_POWER7 */ {0, 10, 0xF6800000},
/* VIBMODE_S_POWER8 */ {0, 11, 0xFB400000},
/* VIBMODE_S_DOKUTT */ {0, 8, 0xC2000000},
/* VIBMODE_S_FOR2D */ {0, 2, 0xC0000000},
};
/* 8037A678-8037A6D0 006CD8 0058+00 0/0 1/1 0/0 .rodata CS_patt__12dVibration_c */
const dVibration_pattern dVibration_c::CS_patt[11] = {
{0x0000, 0x0000, 0x00000000},
{0x0000, 0x0003, 0xC0000000},
{0x0000, 0x0004, 0xE0000000},
{0x0000, 0x0006, 0xE8000000},
{0x0000, 0x0007, 0xEC000000},
{0x0000, 0x0008, 0xF6000000},
{0x0000, 0x0009, 0xFB000000},
{0x0000, 0x000A, 0xF6800000},
{0x0000, 0x000B, 0xFB400000},
{0x0000, 0x0008, 0xC2000000},
{0x0000, 0x0002, 0xC0000000},
// Camera Shock patterns
const vib_pattern dVibration_c::CS_patt[VIBMODE_S_MAX] = {
/* VIBMODE_S_CUSTOM */ {0, 0, 0x00000000},
/* VIBMODE_S_POWER1 */ {0, 3, 0xC0000000},
/* VIBMODE_S_POWER2 */ {0, 4, 0xE0000000},
/* VIBMODE_S_POWER3 */ {0, 6, 0xE8000000},
/* VIBMODE_S_POWER4 */ {0, 7, 0xEC000000},
/* VIBMODE_S_POWER5 */ {0, 8, 0xF6000000},
/* VIBMODE_S_POWER6 */ {0, 9, 0xFB000000},
/* VIBMODE_S_POWER7 */ {0, 10, 0xF6800000},
/* VIBMODE_S_POWER8 */ {0, 11, 0xFB400000},
/* VIBMODE_S_DOKUTT */ {0, 8, 0xC2000000},
/* VIBMODE_S_FOR2D */ {0, 2, 0xC0000000},
};
/* 8037A6D0-8037A720 006D30 0050+00 0/0 1/1 0/0 .rodata MQ_patt__12dVibration_c */
const dVibration_pattern dVibration_c::MQ_patt[10] = {
{0x0000, 0x0000, 0x00000000},
{0x0001, 0x0020, 0x10202020},
{0x0001, 0x0020, 0x42104208},
{0x0002, 0x0020, 0x22222222},
{0x0002, 0x0020, 0x22492249},
{0x0003, 0x0020, 0x52525252},
{0x0003, 0x0020, 0x4A94AA95},
{0x0004, 0x0020, 0x36555655},
{0x0004, 0x0020, 0x6B6D6B6D},
{0x0001, 0x001B, 0x20201000},
// Motor Quake patterns
const vib_pattern dVibration_c::MQ_patt[VIBMODE_Q_MAX] = {
/* VIBMODE_Q_CUSTOM */ {0, 0, 0x00000000},
/* VIBMODE_Q_POWER1 */ {1, 32, 0x10202020},
/* VIBMODE_Q_POWER2 */ {1, 32, 0x42104208},
/* VIBMODE_Q_POWER3 */ {2, 32, 0x22222222},
/* VIBMODE_Q_POWER4 */ {2, 32, 0x22492249},
/* VIBMODE_Q_POWER5 */ {3, 32, 0x52525252},
/* VIBMODE_Q_POWER6 */ {3, 32, 0x4A94AA95},
/* VIBMODE_Q_POWER7 */ {4, 32, 0x36555655},
/* VIBMODE_Q_POWER8 */ {4, 32, 0x6B6D6B6D},
/* VIBMODE_Q_HORSE */ {1, 27, 0x20201000},
};
/* 8037A720-8037A770 006D80 0050+00 0/0 1/1 0/0 .rodata CQ_patt__12dVibration_c */
const dVibration_pattern dVibration_c::CQ_patt[10] = {
{0x0000, 0x0000, 0x00000000},
{0x0001, 0x0020, 0x10202020},
{0x0001, 0x0020, 0x42104208},
{0x0002, 0x0020, 0x22222222},
{0x0002, 0x0020, 0x22492249},
{0x0003, 0x0020, 0x52525252},
{0x0003, 0x0020, 0x4A94AA95},
{0x0004, 0x0020, 0x36555655},
{0x0004, 0x0020, 0x6B6D6B6D},
{0x0000, 0x001B, 0x20201000},
};
// Camera Quake patterns
const vib_pattern dVibration_c::CQ_patt[VIBMODE_Q_MAX] = {
/* VIBMODE_Q_CUSTOM */ {0, 0, 0x00000000},
/* VIBMODE_Q_POWER1 */ {1, 32, 0x10202020},
/* VIBMODE_Q_POWER2 */ {1, 32, 0x42104208},
/* VIBMODE_Q_POWER3 */ {2, 32, 0x22222222},
/* VIBMODE_Q_POWER4 */ {2, 32, 0x22492249},
/* VIBMODE_Q_POWER5 */ {3, 32, 0x52525252},
/* VIBMODE_Q_POWER6 */ {3, 32, 0x4A94AA95},
/* VIBMODE_Q_POWER7 */ {4, 32, 0x36555655},
/* VIBMODE_Q_POWER8 */ {4, 32, 0x6B6D6B6D},
/* VIBMODE_Q_HORSE */ {0, 27, 0x20201000},
};
src/d/d_vibration.cpp
+307 -380
View File
@@ -1,503 +1,427 @@
//
// Generated By: dol2asm
// Translation Unit: d/d_vibration
//
#include "d/d_vibration.h"
#include "d/d_com_inf_game.h"
#include "m_Do/m_Do_controller_pad.h"
#include "SSystem/SComponent/c_math.h"
//
// Forward References:
//
#define RESET_FRAME -99
extern "C" static void func_8006F168__FPUsUll();
extern "C" static void func_8006F184__FUlll();
extern "C" static u32 func_8006F1A4__FUlll();
extern "C" static void func_8006F1D8__Fll();
extern "C" void Run__12dVibration_cFv();
extern "C" void StartShock__12dVibration_cFii4cXyz();
extern "C" void StartQuake__12dVibration_cFii4cXyz();
extern "C" void StartQuake__12dVibration_cFPCUcii4cXyz();
extern "C" void StopQuake__12dVibration_cFi();
extern "C" void Kill__12dVibration_cFv();
extern "C" void CheckQuake__12dVibration_cFv();
extern "C" void setDefault__12dVibration_cFv();
extern "C" void Init__12dVibration_cFv();
extern "C" void Pause__12dVibration_cFv();
extern "C" void Remove__12dVibration_cFv();
extern "C" extern u8 on_final_boss_stg[8];
#define RUMBLE_SHOCK 1
#define RUMBLE_QUAKE 2
//
// External References:
//
extern "C" void checkVibration__19dSv_player_config_cCFv();
extern "C" void StartShake__9dCamera_cFlPUcl4cXyz();
extern "C" void StopShake__9dCamera_cFv();
extern "C" void dCam_getBody__Fv();
extern "C" void dKy_darkworld_check__Fv();
extern "C" void __pl__4cXyzCFRC3Vec();
extern "C" void norm__4cXyzCFv();
extern "C" void cM_rnd__Fv();
extern "C" void stopMotor__Q210JUTGamePad7CRumbleFib();
extern "C" void startPatternedRumble__Q210JUTGamePad7CRumbleFPvQ310JUTGamePad7CRumble7ERumbleUl();
extern "C" void stopPatternedRumble__Q210JUTGamePad7CRumbleFs();
extern "C" void stopPatternedRumbleAtThePeriod__Q210JUTGamePad7CRumbleFv();
extern "C" void __cvt_fp2unsigned();
extern "C" void _savegpr_26();
extern "C" void _savegpr_29();
extern "C" void _restgpr_26();
extern "C" void _restgpr_29();
extern "C" u8 const MS_patt__12dVibration_c[88];
extern "C" u8 const CS_patt__12dVibration_c[88];
extern "C" u8 const MQ_patt__12dVibration_c[80];
extern "C" u8 const CQ_patt__12dVibration_c[80];
extern "C" u8 m_gamePad__8mDoCPd_c[16];
//
// Declarations:
//
#define FLAG_CAMERA_VIB 0x7E
#define FLAG_MOTOR_VIB 0x1
namespace {
/* 8006F168-8006F184 069AA8 001C+00 1/1 0/0 0/0 .text makedata__25@unnamed@d_vibration_cpp@FPUsUll
*/
static u16* func_8006F168(u16* param_0, u32 param_1, s32 param_2) {
param_0[0] = param_2;
param_0[1] = param_1 >> 16;
param_0[2] = param_1;
param_0[3] = 0;
return param_0;
u16* makedata(u16* data, u32 pattern, s32 length) {
data[0] = length;
data[1] = pattern >> 16;
data[2] = pattern;
data[3] = 0;
return data;
}
/* 8006F184-8006F1A4 069AC4 0020+00 1/1 0/0 0/0 .text rollshift__25@unnamed@d_vibration_cpp@FUlll
*/
static s32 func_8006F184(u32 param_0, s32 param_1, s32 param_2) {
s32 temp = param_2 / param_1;
temp = temp * param_1;
temp = param_2 - temp;
param_2 = param_0 >> temp;
temp = param_1 - temp;
temp = param_0 << temp;
return param_2 | temp;
s32 rollshift(u32 pattern, s32 length, s32 index) {
index %= length;
return (pattern >> index) | (pattern << (length - index));
}
/* 8006F1A4-8006F1D8 069AE4 0034+00 2/2 0/0 0/0 .text makebits__25@unnamed@d_vibration_cpp@FUlll
*/
static u32 func_8006F1A4(u32 param_0, s32 param_1, s32 param_2) {
s32 uVar1 = -1;
u32 temp = param_0 & (uVar1 << (32 - param_1));
param_0 = temp;
uVar1 = param_1;
while (uVar1 < param_2) {
param_0 = temp | (param_0 >> param_1);
uVar1 += param_1;
}
return param_0;
}
u32 makebits(u32 bits, s32 length, s32 numbits) {
s32 i;
u32 mask = bits & (-1 << (32 - length));
bits = mask;
/* ############################################################################################## */
for (i = length; i < numbits; i += length) {
bits = mask | (bits >> length);
}
return bits;
}
/* 8006F1D8-8006F268 069B18 0090+00 1/1 0/0 0/0 .text randombit__25@unnamed@d_vibration_cpp@Fll */
static u32 func_8006F1D8(s32 param_0, s32 param_1) {
u32 uVar3 = 0;
u32 randombit(s32 rounds, s32 length) {
u32 value = 0;
for (s32 iVar2 = 0; iVar2 < param_0; iVar2++) {
u32 dVar4 = param_1 * cM_rnd();
uVar3 |= 0x40000000 >> dVar4;
for (int i = 0; i < rounds; i++) {
value |= 0x40000000 >> (u32)(length * cM_rnd());
}
return uVar3;
return value;
}
/* ############################################################################################## */
/* 80450F50-80450F58 000450 0008+00 1/1 0/0 0/0 .sbss data$3831 */
static u16 data[4];
};
/* 8006F268-8006FA24 069BA8 07BC+00 0/0 2/2 0/0 .text Run__12dVibration_cFv */
// Stack issues
#ifdef NONMATCHING
int dVibration_c::Run() {
mMode = MODE_RUN;
field_0x8c = 1;
if (dComIfGs_checkOptVibration() != 1) {
if (field_0x54 != -1) {
field_0x54 = -1;
field_0x50 |= 1;
if (mMotor.mShock.mVibMode != VIBMODE_S_NONE) {
mMotor.mShock.mVibMode = VIBMODE_S_NONE;
mMotor.mShock.field_0x0 |= 1;
}
if (field_0x70 != -1) {
field_0x70 = -1;
field_0x6c |= 1;
if (mMotor.mQuake.mVibMode != VIBMODE_Q_NONE) {
mMotor.mQuake.mVibMode = VIBMODE_Q_NONE;
mMotor.mQuake.field_0x0 |= 1;
}
field_0x80 = -99;
field_0x64 = 0xffffff9d;
mMotor.mQuake.mFrame = RESET_FRAME;
mMotor.mShock.mFrame = RESET_FRAME;
}
if (((field_0x0.mShock.field_0x0 & 1) != 0) && (field_0x0.mShock.field_0x24 != -99)) {
field_0x0.mShock.field_0x24 = 0;
field_0x0.mShock.field_0x4 = -1;
}
if (((field_0x0.mQuake.field_0x0 & 1) != 0) && (field_0x0.mQuake.field_0x24 != -99)) {
field_0x0.mQuake.field_0x24 = 0;
field_0x0.mQuake.field_0x4 = -1;
if ((mCamera.mShock.field_0x0 & 1) && mCamera.mShock.mFrame != RESET_FRAME) {
mCamera.mShock.mFrame = 0;
mCamera.mShock.mVibMode = VIBMODE_S_NONE;
}
if (field_0x0.mShock.field_0x24 == 0 || field_0x0.mQuake.field_0x24 == 0) {
s32 local_68 = 0;
if (field_0x0.mShock.field_0x4 == -1 || (field_0x0.mShock.field_0x0 & 1) != 0) {
field_0x0.mShock.field_0x24 = -99;
field_0x0.mShock.field_0x8 = 0;
field_0x0.mShock.field_0xc = 0;
field_0x0.mShock.field_0x10 = 0;
} else if (field_0x0.mShock.field_0x24 >= 0) {
local_68 |= 1;
if ((mCamera.mQuake.field_0x0 & 1) && mCamera.mQuake.mFrame != RESET_FRAME) {
mCamera.mQuake.mFrame = 0;
mCamera.mQuake.mVibMode = VIBMODE_Q_NONE;
}
if (mCamera.mShock.mFrame == 0 || mCamera.mQuake.mFrame == 0) {
u32 rumble = 0;
if (mCamera.mShock.mVibMode == VIBMODE_S_NONE || (mCamera.mShock.field_0x0 & 1)) {
mCamera.mShock.mFrame = RESET_FRAME;
mCamera.mShock.mPattern = 0;
mCamera.mShock.mLength = 0;
mCamera.mShock.mRounds = 0;
} else if (mCamera.mShock.mFrame >= 0) {
rumble |= RUMBLE_SHOCK;
}
if (field_0x0.mQuake.field_0x4 == -1 || (field_0x0.mQuake.field_0x0 & 1) != 0) {
field_0x0.mQuake.field_0x24 = -99;
field_0x0.mQuake.field_0x8 = 0;
field_0x0.mQuake.field_0xc = 0;
field_0x0.mQuake.field_0x10 = 0;
} else if (field_0x0.mQuake.field_0x24 >= 0) {
local_68 |= 2;
if (mCamera.mQuake.mVibMode == VIBMODE_Q_NONE || (mCamera.mQuake.field_0x0 & 1)) {
mCamera.mQuake.mFrame = RESET_FRAME;
mCamera.mQuake.mPattern = 0;
mCamera.mQuake.mLength = 0;
mCamera.mQuake.mRounds = 0;
} else if (mCamera.mQuake.mFrame >= 0) {
rumble |= RUMBLE_QUAKE;
}
switch (local_68) {
case 1:
s32 x = field_0x0.mShock.field_0xc;
u32 local_60 = field_0x0.mShock.field_0x8;
local_60 |= func_8006F1D8(field_0x0.mShock.field_0x10, x);
s32 uVar3 = field_0x0.mShock.field_0x14;
s32 length, pattern, bits, flags;
switch (rumble) {
case RUMBLE_SHOCK:
length = mCamera.mShock.mLength;
pattern = mCamera.mShock.mPattern;
pattern |= randombit(mCamera.mShock.mRounds, length);
flags = mCamera.mShock.mFlags;
if (dKy_darkworld_check()) {
uVar3 &= ~0x30;
flags &= ~0x30;
}
camera_class* pCamera = dComIfGp_getCamera(0);
if (pCamera && pCamera->field_0x22f == 0x47) {
dCam_getBody()->StartShake(x, (u8*)&local_60, uVar3, field_0x0.mShock.field_0x18.norm());
if (dComIfGp_getCamera(0) != NULL && dComIfGp_getCamera(0)->field_0x22f == 0x47) {
dCam_getBody()->StartShake(length, (u8*)&pattern, flags, mCamera.mShock.mPos.norm());
}
break;
case 2:
x = field_0x0.mQuake.field_0xc;
local_60 = func_8006F184(field_0x0.mQuake.field_0x8, x, field_0x88);
local_60 |= func_8006F1D8(field_0x0.mQuake.field_0x10, x);
uVar3 = field_0x0.mQuake.field_0x14;
case RUMBLE_QUAKE:
length = mCamera.mQuake.mLength;
pattern = rollshift(mCamera.mQuake.mPattern, length, mFrame);
pattern |= randombit(mCamera.mQuake.mRounds, length);
flags = mCamera.mQuake.mFlags;
if (dKy_darkworld_check()) {
uVar3 &= ~0x30;
flags &= ~0x30;
}
pCamera = dComIfGp_getCamera(0);
if (pCamera && pCamera->field_0x22f == 0x47) {
dCam_getBody()->StartShake(x, (u8*)&local_60, uVar3, field_0x0.mQuake.field_0x18.norm());
if (dComIfGp_getCamera(0) != NULL && dComIfGp_getCamera(0)->field_0x22f == 0x47) {
dCam_getBody()->StartShake(length, (u8*)&pattern, flags, mCamera.mQuake.mPos.norm());
}
break;
case 3:
local_60 = field_0x0.mShock.field_0x8 << field_0x0.mShock.field_0x24;
x = field_0x0.mShock.field_0xc - field_0x0.mShock.field_0x24;
local_60 |= func_8006F184(func_8006F1A4(field_0x0.mQuake.field_0x8, field_0x0.mQuake.field_0xc, x), x, field_0x88);
local_60 |= func_8006F1D8(
field_0x0.mShock.field_0x10 > field_0x0.mQuake.field_0x10 ? field_0x0.mShock.field_0x10 : field_0x0.mQuake.field_0x10,
x
);
uVar3 = field_0x0.mShock.field_0x14 | field_0x0.mQuake.field_0x14;
case RUMBLE_SHOCK | RUMBLE_QUAKE:
pattern = mCamera.mShock.mPattern << mCamera.mShock.mFrame;
length = mCamera.mShock.mLength - mCamera.mShock.mFrame;
pattern |= rollshift(makebits(mCamera.mQuake.mPattern, mCamera.mQuake.mLength, length), length, mFrame);
pattern |= randombit(mCamera.mShock.mRounds > mCamera.mQuake.mRounds ? mCamera.mShock.mRounds : mCamera.mQuake.mRounds, length);
flags = mCamera.mShock.mFlags | mCamera.mQuake.mFlags;
if (dKy_darkworld_check()) {
uVar3 &= ~0x30;
flags &= ~0x30;
}
pCamera = dComIfGp_getCamera(0);
if (pCamera && pCamera->field_0x22f == 0x47) {
cXyz tempSum = field_0x0.mShock.field_0x18 + field_0x0.mQuake.field_0x18;
dCam_getBody()->StartShake(x, (u8*)&local_60, uVar3, tempSum.norm());
if (dComIfGp_getCamera(0) != NULL && dComIfGp_getCamera(0)->field_0x22f == 0x47) {
dCam_getBody()->StartShake(length, (u8*)&pattern, flags, cXyz(mCamera.mShock.mPos + mCamera.mQuake.mPos).norm());
}
field_0x0.mQuake.field_0x24 = 0;
field_0x0.mShock.field_0x24 = 0;
mCamera.mQuake.mFrame = 0;
mCamera.mShock.mFrame = 0;
break;
default:
pCamera = dComIfGp_getCamera(0);
if (pCamera && pCamera->field_0x22f == 0x47) {
if (dComIfGp_getCamera(0) != NULL && dComIfGp_getCamera(0)->field_0x22f == 0x47) {
dCam_getBody()->StopShake();
}
break;
}
}
if (((field_0x50 & 1) != 0) && (field_0x64 != -99)) {
field_0x64 = 0;
field_0x54 = -1;
if ((mMotor.mShock.field_0x0 & 1) && mMotor.mShock.mFrame != RESET_FRAME) {
mMotor.mShock.mFrame = 0;
mMotor.mShock.mVibMode = VIBMODE_S_NONE;
}
if (((field_0x6c & 1) != 0) && (field_0x80 != -99)) {
field_0x80 = 0;
field_0x70 = -1;
if ((mMotor.mQuake.field_0x0 & 1) && mMotor.mQuake.mFrame != RESET_FRAME) {
mMotor.mQuake.mFrame = 0;
mMotor.mQuake.mVibMode = VIBMODE_Q_NONE;
}
if (field_0x64 == 0 || field_0x80 == 0) {
s32 local_68 = 0;
if (field_0x54 == -1 || (field_0x50 & 1) != 0) {
field_0x64 = -99;
field_0x58 = 0;
field_0x5c = 0;
field_0x60 = 0;
} else if (field_0x64 >= 0) {
local_68 |= 1;
if (mMotor.mShock.mFrame == 0 || mMotor.mQuake.mFrame == 0) {
u32 rumble = 0;
if (mMotor.mShock.mVibMode == VIBMODE_S_NONE || (mMotor.mShock.field_0x0 & 1)) {
mMotor.mShock.mFrame = RESET_FRAME;
mMotor.mShock.mPattern = 0;
mMotor.mShock.mLength = 0;
mMotor.mShock.mRounds = 0;
} else if (mMotor.mShock.mFrame >= 0) {
rumble |= RUMBLE_SHOCK;
}
if (field_0x70 == -1 || (field_0x6c & 1) != 0) {
field_0x80 = -99;
field_0x74 = 0;
field_0x78 = 0;
field_0x7c = 0;
} else if (field_0x80 >= 0) {
local_68 |= 2;
if (mMotor.mQuake.mVibMode == VIBMODE_Q_NONE || (mMotor.mQuake.field_0x0 & 1)) {
mMotor.mQuake.mFrame = RESET_FRAME;
mMotor.mQuake.mPattern = 0;
mMotor.mQuake.mLength = 0;
mMotor.mQuake.mRounds = 0;
} else if (mMotor.mQuake.mFrame >= 0) {
rumble |= RUMBLE_QUAKE;
}
switch (local_68) {
case 1:
u32 local_60;
s32 x = field_0x5c;
local_60 = field_0x58;
local_60 |= func_8006F1D8(field_0x60, x);
field_0x68 = x;
mDoCPd_c::startMotorWave(0, func_8006F168(data, local_60, x), JUTGamePad::CRumble::VAL_0, 0x3c);
static u16 data[4];
s32 pattern, length, bits;
switch (rumble) {
case RUMBLE_SHOCK:
length = mMotor.mShock.mLength;
pattern = mMotor.mShock.mPattern;
pattern |= randombit(mMotor.mShock.mRounds, length);
mMotor.mShock.mStopFrame = length;
mDoCPd_c::startMotorWave(PAD_1, makedata(data, pattern, length), JUTGamePad::CRumble::VAL_0, 60);
break;
case 2:
x = field_0x78;
local_60 = func_8006F184(field_0x74, x, field_0x88);
local_60 |= func_8006F1D8(field_0x7c, x);
field_0x84 = 0x7fffffff;
mDoCPd_c::startMotorWave(0, func_8006F168(data, local_60, x), JUTGamePad::CRumble::VAL_1, 0x3c);
case RUMBLE_QUAKE:
length = mMotor.mQuake.mLength;
pattern = rollshift(mMotor.mQuake.mPattern, length, mFrame);
pattern |= randombit(mMotor.mQuake.mRounds, length);
mMotor.mQuake.mStopFrame = INT32_MAX;
mDoCPd_c::startMotorWave(PAD_1, makedata(data, pattern, length), JUTGamePad::CRumble::VAL_1, 60);
break;
case 3:
local_60 = field_0x58 << field_0x64;
x = field_0x5c - field_0x64;
local_60 |= func_8006F184(func_8006F1A4(field_0x74, field_0x78, x), x, field_0x88);
local_60 |= func_8006F1D8(
field_0x60 > field_0x7c ? field_0x60 : field_0x7c,
x
);
field_0x84 = x;
field_0x68 = x;
field_0x80 = 0;
field_0x64 = 0;
mDoCPd_c::startMotorWave(0, func_8006F168(data, local_60, x), JUTGamePad::CRumble::VAL_0, 0x3c);
case RUMBLE_SHOCK | RUMBLE_QUAKE:
pattern = mMotor.mShock.mPattern << mMotor.mShock.mFrame;
length = mMotor.mShock.mLength - mMotor.mShock.mFrame;
pattern |= rollshift(makebits(mMotor.mQuake.mPattern, mMotor.mQuake.mLength, length), length, mFrame);
pattern |= randombit(mMotor.mShock.mRounds > mMotor.mQuake.mRounds ? mMotor.mShock.mRounds : mMotor.mQuake.mRounds, length);
mMotor.mQuake.mStopFrame = length;
mMotor.mShock.mStopFrame = length;
mMotor.mQuake.mFrame = 0;
mMotor.mShock.mFrame = 0;
mDoCPd_c::startMotorWave(PAD_1, makedata(data, pattern, length), JUTGamePad::CRumble::VAL_0, 60);
break;
default:
mDoCPd_c::stopMotorWave(0);
mDoCPd_c::stopMotor(0);
field_0x84 = -99;
field_0x68 = -99;
mDoCPd_c::stopMotorWave(PAD_1);
mDoCPd_c::stopMotor(PAD_1);
mMotor.mQuake.mStopFrame = RESET_FRAME;
mMotor.mShock.mStopFrame = RESET_FRAME;
break;
}
}
field_0x0.mQuake.field_0x0 = 0;
field_0x0.mShock.field_0x0 = 0;
field_0x6c = 0;
field_0x50 = 0;
mCamera.mQuake.field_0x0 = 0;
mCamera.mShock.field_0x0 = 0;
mMotor.mQuake.field_0x0 = 0;
mMotor.mShock.field_0x0 = 0;
if (field_0x0.mShock.field_0x24 >= 0) {
field_0x0.mShock.field_0x24++;
if (mCamera.mShock.mFrame >= 0) {
mCamera.mShock.mFrame++;
if (field_0x0.mShock.field_0x24 > field_0x0.mShock.field_0xc) {
field_0x0.mShock.field_0x0 |= 1;
if (mCamera.mShock.mFrame > mCamera.mShock.mLength) {
mCamera.mShock.field_0x0 |= 1;
}
}
if (field_0x64 >= 0) {
field_0x64++;
if (mMotor.mShock.mFrame >= 0) {
mMotor.mShock.mFrame++;
if (field_0x64 > field_0x68) {
field_0x50 |= 1;
if (mMotor.mShock.mFrame > mMotor.mShock.mStopFrame) {
mMotor.mShock.field_0x0 |= 1;
}
}
if (field_0x0.mQuake.field_0x24 >= 0) {
field_0x0.mQuake.field_0x24++;
if (mCamera.mQuake.mFrame >= 0) {
mCamera.mQuake.mFrame++;
if (field_0x0.mQuake.field_0x24 > field_0x0.mQuake.field_0xc) {
field_0x0.mQuake.field_0x24 = 0;
if (mCamera.mQuake.mFrame > mCamera.mQuake.mLength) {
mCamera.mQuake.mFrame = 0;
}
}
if (field_0x80 >= 930) {
field_0x80 = 0;
} else if (field_0x80 >= 900) {
mDoCPd_c::stopMotorWave(0);
mDoCPd_c::stopMotor(0);
field_0x80++;
} else if (field_0x80 >= 0) {
field_0x80++;
if (field_0x80 > field_0x84) {
field_0x80 = 0;
if (mMotor.mQuake.mFrame >= 930) {
mMotor.mQuake.mFrame = 0;
} else if (mMotor.mQuake.mFrame >= 900) {
mDoCPd_c::stopMotorWave(PAD_1);
mDoCPd_c::stopMotor(PAD_1);
mMotor.mQuake.mFrame++;
} else if (mMotor.mQuake.mFrame >= 0) {
mMotor.mQuake.mFrame++;
if (mMotor.mQuake.mFrame > mMotor.mQuake.mStopFrame) {
mMotor.mQuake.mFrame = 0;
}
}
field_0x88++;
mFrame++;
return 1;
}
#else
int dVibration_c::Run() {
// NONMATCHING
}
#endif
/* 8006FA24-8006FB10 06A364 00EC+00 0/0 62/62 298/298 .text StartShock__12dVibration_cFii4cXyz */
bool dVibration_c::StartShock(int param_0, int param_1, cXyz param_2) {
bool dVibration_c::StartShock(int i_vibmode, int i_flags, cXyz i_pos) {
bool ret = false;
if (param_1 & 0x7eU) {
field_0x0.mShock.field_0x4 = param_0;
field_0x0.mShock.field_0x24 = 0;
field_0x0.mShock.field_0x14 = param_1;
field_0x0.mShock.field_0x18 = param_2;
field_0x0.mShock.field_0x8 = CS_patt[param_0].field_0x04;
field_0x0.mShock.field_0xc = CS_patt[param_0].field_0x02;
field_0x0.mShock.field_0x10 = CS_patt[param_0].field_0x00;
if (i_flags & FLAG_CAMERA_VIB) {
mCamera.mShock.mVibMode = i_vibmode;
mCamera.mShock.mFrame = 0;
mCamera.mShock.mFlags = i_flags;
mCamera.mShock.mPos = i_pos;
mCamera.mShock.mPattern = CS_patt[i_vibmode].bits;
mCamera.mShock.mLength = CS_patt[i_vibmode].length;
mCamera.mShock.mRounds = CS_patt[i_vibmode].rounds;
ret = true;
}
if (param_1 & 1 && dComIfGs_checkOptVibration() == 1) {
field_0x54 = param_0;
field_0x64 = 0;
field_0x58 = MS_patt[param_0].field_0x04;
field_0x5c = MS_patt[param_0].field_0x02;
if ((i_flags & FLAG_MOTOR_VIB) && dComIfGs_checkOptVibration() == 1) {
mMotor.mShock.mVibMode = i_vibmode;
mMotor.mShock.mFrame = 0;
mMotor.mShock.mPattern = MS_patt[i_vibmode].bits;
mMotor.mShock.mLength = MS_patt[i_vibmode].length;
ret = true;
}
return ret;
}
/* 8006FB10-8006FC0C 06A450 00FC+00 0/0 8/8 67/67 .text StartQuake__12dVibration_cFii4cXyz */
bool dVibration_c::StartQuake(int param_0, int param_1, cXyz param_2) {
bool dVibration_c::StartQuake(int i_vibmode, int i_flags, cXyz i_pos) {
bool ret = false;
if (param_1 & 0x7eU) {
field_0x0.mQuake.field_0x4 = param_0;
field_0x0.mQuake.field_0x24 = 0;
field_0x0.mQuake.field_0x14 = param_1;
field_0x0.mQuake.field_0x18 = param_2;
field_0x0.mQuake.field_0x8 = CQ_patt[param_0].field_0x04;
field_0x0.mQuake.field_0xc = CQ_patt[param_0].field_0x02;
field_0x0.mQuake.field_0x10 = CQ_patt[param_0].field_0x00;
if (i_flags & FLAG_CAMERA_VIB) {
mCamera.mQuake.mVibMode = i_vibmode;
mCamera.mQuake.mFrame = 0;
mCamera.mQuake.mFlags = i_flags;
mCamera.mQuake.mPos = i_pos;
mCamera.mQuake.mPattern = CQ_patt[i_vibmode].bits;
mCamera.mQuake.mLength = CQ_patt[i_vibmode].length;
mCamera.mQuake.mRounds = CQ_patt[i_vibmode].rounds;
ret = true;
}
if (param_1 & 1 && dComIfGs_checkOptVibration() == 1) {
field_0x70 = param_0;
field_0x80 = 0;
field_0x74 = MQ_patt[param_0].field_0x04;
field_0x78 = MQ_patt[param_0].field_0x02;
field_0x7c = CQ_patt[param_0].field_0x00;
if ((i_flags & FLAG_MOTOR_VIB) && dComIfGs_checkOptVibration() == 1) {
mMotor.mQuake.mVibMode = i_vibmode;
mMotor.mQuake.mFrame = 0;
mMotor.mQuake.mPattern = MQ_patt[i_vibmode].bits;
mMotor.mQuake.mLength = MQ_patt[i_vibmode].length;
mMotor.mQuake.mRounds = CQ_patt[i_vibmode].rounds;
ret = true;
}
return ret;
}
/* 8006FC0C-8006FD94 06A54C 0188+00 0/0 2/2 2/2 .text StartQuake__12dVibration_cFPCUcii4cXyz */
bool dVibration_c::StartQuake(u8 const* param_0, int param_1, int param_2, cXyz param_3) {
int iVar7;
int iVar6;
int iVar5;
int iVar4;
bool bVar8 = false;
int uVar1 = (param_0[0] << 8) | param_0[1];
if (uVar1 >= 9) {
iVar7 = 3;
} else {
iVar7 = 0;
bool dVibration_c::StartQuake(const u8* i_pattern, int i_rounds, int i_flags, cXyz i_pos) {
bool ret = false;
int length = (i_pattern[0] << 8) | i_pattern[1];
u32 bits = i_pattern[length >= 1 ? 2 : 0] << 24 |
i_pattern[length >= 9 ? 3 : 0] << 16 |
i_pattern[length >= 17 ? 4 : 0] << 8 |
i_pattern[length >= 25 ? 5 : 0] << 0;
if (i_flags & FLAG_CAMERA_VIB) {
mCamera.mQuake.mVibMode = VIBMODE_Q_CUSTOM;
mCamera.mQuake.mFrame = 0;
mCamera.mQuake.mFlags = i_flags;
mCamera.mQuake.mPos = i_pos;
mCamera.mQuake.mPattern = makebits(bits, i_pattern[1], 32);
mCamera.mQuake.mLength = 32;
mCamera.mQuake.mRounds = i_rounds;
ret = true;
}
if (uVar1 >= 1) {
iVar6 = 2;
} else {
iVar6 = 0;
if ((i_flags & FLAG_MOTOR_VIB) && dComIfGs_checkOptVibration() == 1) {
mMotor.mQuake.mVibMode = VIBMODE_Q_CUSTOM;
mMotor.mQuake.mFrame = 0;
mMotor.mQuake.mPattern = makebits(bits, i_pattern[1], 32);
mMotor.mQuake.mLength = 32;
mMotor.mQuake.mRounds = i_rounds;
ret = true;
}
if (uVar1 >= 0x11) {
iVar5 = 4;
} else {
iVar5 = 0;
}
if (uVar1 >= 0x19) {
iVar4 = 5;
} else {
iVar4 = 0;
}
u32 this_00 =
param_0[iVar6] << 24 | param_0[iVar7] << 16 | param_0[iVar5] << 8 | (param_0[iVar4]);
if ((param_2 & 0x7e) != 0) {
field_0x0.mQuake.field_0x4 = 0;
field_0x0.mQuake.field_0x24 = 0;
field_0x0.mQuake.field_0x14 = param_2;
field_0x0.mQuake.field_0x18 = param_3;
field_0x0.mQuake.field_0x8 = func_8006F1A4(this_00, param_0[1], 0x20);
field_0x0.mQuake.field_0xc = 0x20;
field_0x0.mQuake.field_0x10 = param_1;
bVar8 = true;
}
if (((param_2 & 1) != 0) &&
(dComIfGs_checkOptVibration() == 1))
{
field_0x70 = 0;
field_0x80 = 0;
field_0x74 = func_8006F1A4(this_00, param_0[1], 0x20);
field_0x78 = 0x20;
field_0x7c = param_1;
bVar8 = true;
}
return bVar8;
return ret;
}
/* 8006FD94-8006FE00 06A6D4 006C+00 0/0 6/6 82/82 .text StopQuake__12dVibration_cFi */
int dVibration_c::StopQuake(int param_0) {
int ret = 0;
if (param_0 & 0x7eU) {
if (field_0x0.mQuake.field_0x24 >= 0) {
field_0x0.mQuake.field_0x14 &= ~param_0;
if (field_0x0.mQuake.field_0x14 == 0) {
field_0x0.mQuake.field_0x0 |= 1;
int dVibration_c::StopQuake(int i_flags) {
int ret = FALSE;
if (i_flags & FLAG_CAMERA_VIB) {
if (mCamera.mQuake.mFrame >= 0) {
mCamera.mQuake.mFlags &= ~i_flags;
if (mCamera.mQuake.mFlags == 0) {
mCamera.mQuake.field_0x0 |= 1;
}
ret = 1;
ret = TRUE;
}
}
if (param_0 & 1 && field_0x80 >= 0) {
field_0x6c |= 1;
ret = 1;
if ((i_flags & FLAG_MOTOR_VIB) && mMotor.mQuake.mFrame >= 0) {
mMotor.mQuake.field_0x0 |= 1;
ret = TRUE;
}
return ret;
}
/* 8006FE00-8006FE5C 06A740 005C+00 2/2 0/0 0/0 .text Kill__12dVibration_cFv */
void dVibration_c::Kill() {
mDoCPd_c::stopMotorWaveHard(0);
mDoCPd_c::stopMotorHard(0);
mDoCPd_c::stopMotorWaveHard(PAD_1);
mDoCPd_c::stopMotorHard(PAD_1);
setDefault();
}
/* 8006FE5C-8006FE84 06A79C 0028+00 0/0 0/0 10/10 .text CheckQuake__12dVibration_cFv */
bool dVibration_c::CheckQuake() {
return field_0x0.mQuake.field_0x4 != -1 || field_0x70 != -1;
return mCamera.mQuake.mVibMode != VIBMODE_Q_NONE || mMotor.mQuake.mVibMode != VIBMODE_Q_NONE;
}
/* 8006FE84-8006FF04 06A7C4 0080+00 2/2 0/0 0/0 .text setDefault__12dVibration_cFv */
void dVibration_c::setDefault() {
field_0x54 = -1;
field_0x0.mShock.field_0x4 = -1;
field_0x70 = -1;
field_0x0.mQuake.field_0x4 = -1;
field_0x50 = 0;
field_0x0.mShock.field_0x0 = 0;
field_0x6c = 0;
field_0x0.mQuake.field_0x0 = 0;
field_0x58 = 0;
field_0x0.mShock.field_0x8 = 0;
field_0x74 = 0;
field_0x0.mQuake.field_0x8 = 0;
field_0x5c = 0;
field_0x0.mShock.field_0xc = 0;
field_0x78 = 0;
field_0x0.mQuake.field_0xc = 0;
field_0x60 = 0;
field_0x0.mShock.field_0x10 = 0;
field_0x7c = 0;
field_0x0.mQuake.field_0x10 = 0;
field_0x64 = -99;
field_0x0.mShock.field_0x24 = -99;
field_0x80 = -99;
field_0x0.mQuake.field_0x24 = -99;
field_0x68 = -99;
field_0x84 = -99;
field_0x8c = 0;
field_0x88 = 0;
mMotor.mShock.mVibMode = VIBMODE_S_NONE;
mCamera.mShock.mVibMode = VIBMODE_S_NONE;
mMotor.mQuake.mVibMode = VIBMODE_Q_NONE;
mCamera.mQuake.mVibMode = VIBMODE_Q_NONE;
mMotor.mShock.field_0x0 = 0;
mCamera.mShock.field_0x0 = 0;
mMotor.mQuake.field_0x0 = 0;
mCamera.mQuake.field_0x0 = 0;
mMotor.mShock.mPattern = 0;
mCamera.mShock.mPattern = 0;
mMotor.mQuake.mPattern = 0;
mCamera.mQuake.mPattern = 0;
mMotor.mShock.mLength = 0;
mCamera.mShock.mLength = 0;
mMotor.mQuake.mLength = 0;
mCamera.mQuake.mLength = 0;
mMotor.mShock.mRounds = 0;
mCamera.mShock.mRounds = 0;
mMotor.mQuake.mRounds = 0;
mCamera.mQuake.mRounds = 0;
mMotor.mShock.mFrame = RESET_FRAME;
mCamera.mShock.mFrame = RESET_FRAME;
mMotor.mQuake.mFrame = RESET_FRAME;
mCamera.mQuake.mFrame = RESET_FRAME;
mMotor.mShock.mStopFrame = RESET_FRAME;
mMotor.mQuake.mStopFrame = RESET_FRAME;
mMode = MODE_WAIT;
mFrame = 0;
}
/* 8006FF04-8006FF38 06A844 0034+00 0/0 2/2 0/0 .text Init__12dVibration_cFv */
@@ -508,26 +432,29 @@ void dVibration_c::Init() {
/* 8006FF38-8006FFF8 06A878 00C0+00 0/0 1/1 0/0 .text Pause__12dVibration_cFv */
void dVibration_c::Pause() {
if (field_0x8c != -1) {
if (field_0x54 != -1 || field_0x70 != -1) {
mDoCPd_c::stopMotorWaveHard(0);
mDoCPd_c::stopMotorHard(0);
if (mMode != MODE_PAUSE) {
if (mMotor.mShock.mVibMode != VIBMODE_S_NONE || mMotor.mQuake.mVibMode != VIBMODE_Q_NONE) {
mDoCPd_c::stopMotorWaveHard(PAD_1);
mDoCPd_c::stopMotorHard(PAD_1);
}
field_0x54 = -1;
field_0x0.mShock.field_0x4 = -1;
field_0x64 = -99;
field_0x0.mShock.field_0x24 = -99;
if (field_0x0.mQuake.field_0x4 != -1) {
field_0x0.mQuake.field_0x24 = 0;
mMotor.mShock.mVibMode = VIBMODE_S_NONE;
mCamera.mShock.mVibMode = VIBMODE_S_NONE;
mMotor.mShock.mFrame = RESET_FRAME;
mCamera.mShock.mFrame = RESET_FRAME;
if (mCamera.mQuake.mVibMode != VIBMODE_Q_NONE) {
mCamera.mQuake.mFrame = 0;
}
if (field_0x70 != -1) {
field_0x80 = 0;
if (mMotor.mQuake.mVibMode != VIBMODE_Q_NONE) {
mMotor.mQuake.mFrame = 0;
}
field_0x8c = -1;
mMode = MODE_PAUSE;
}
}
/* 8006FFF8-80070018 06A938 0020+00 0/0 1/1 0/0 .text Remove__12dVibration_cFv */
void dVibration_c::Remove() {
Kill();
}
}
src/m_Do/m_Do_controller_pad.cpp
+5 -5
View File
@@ -17,13 +17,13 @@ interface_of_controller_pad mDoCPd_c::m_cpadInfo[4];
/* 80007954-80007A94 002294 0140+00 0/0 1/1 0/0 .text create__8mDoCPd_cFv */
void mDoCPd_c::create() {
JUTGamePad* pad = new JUTGamePad(JUTGamePad::Port_1);
JUTGamePad* pad = new JUTGamePad(JUTGamePad::EPort1);
m_gamePad[0] = pad;
if (mDoMain::developmentMode != 0) {
m_gamePad[1] = new JUTGamePad(JUTGamePad::Port_2);
m_gamePad[2] = new JUTGamePad(JUTGamePad::Port_3);
m_gamePad[3] = new JUTGamePad(JUTGamePad::Port_4);
m_gamePad[1] = new JUTGamePad(JUTGamePad::EPort2);
m_gamePad[2] = new JUTGamePad(JUTGamePad::EPort3);
m_gamePad[3] = new JUTGamePad(JUTGamePad::EPort4);
} else {
m_gamePad[1] = NULL;
m_gamePad[2] = NULL;
@@ -126,4 +126,4 @@ void mDoCPd_c::LRlockCheck(interface_of_controller_pad* interface) {
void mDoCPd_c::recalibrate(void) {
JUTGamePad::clearForReset();
JUTGamePad::CRumble::setEnabled(PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT);
}
}
src/m_Do/m_Do_machine.cpp
+13 -13
View File
@@ -177,8 +177,8 @@ static int developKeyCheck(u32 btnTrig, u32 btnHold) {
static u8 key_ganon;
static u8 key_zelda;
if (btnHold == (CButton::L | CButton::R | CButton::Z | CButton::DPAD_DOWN) &&
btnTrig == CButton::DPAD_DOWN) {
if (btnHold == (PAD_TRIGGER_L | PAD_TRIGGER_R | PAD_TRIGGER_Z | PAD_BUTTON_DOWN) &&
btnTrig == PAD_BUTTON_DOWN) {
if (key_link == 3 && key_ganon == 6 && key_zelda == 5) {
mDoMain::developmentMode = 1;
} else {
@@ -188,15 +188,15 @@ static int developKeyCheck(u32 btnTrig, u32 btnHold) {
}
}
if (btnHold == (CButton::L | CButton::DPAD_RIGHT) && btnTrig == CButton::L) {
if (btnHold == (PAD_TRIGGER_L | PAD_BUTTON_RIGHT) && btnTrig == PAD_TRIGGER_L) {
key_link++;
}
if (btnHold == (CButton::R | CButton::DPAD_UP) && btnTrig == CButton::R) {
if (btnHold == (PAD_TRIGGER_R | PAD_BUTTON_UP) && btnTrig == PAD_TRIGGER_R) {
key_ganon++;
}
if (btnHold == (CButton::Z | CButton::DPAD_LEFT) && btnTrig == CButton::Z) {
if (btnHold == (PAD_TRIGGER_Z | PAD_BUTTON_LEFT) && btnTrig == PAD_TRIGGER_Z) {
key_zelda++;
}
@@ -241,7 +241,7 @@ void myExceptionCallback(u16, OSContext*, u32, u32) {
} else {
manager->setTraceSuppress(0x80);
if (mDoMain::developmentMode == 0) {
JUTGamePad pad(JUTGamePad::Port_1);
JUTGamePad pad(JUTGamePad::EPort1);
manager->setGamePad(&pad);
if (manager != NULL) {
@@ -289,7 +289,7 @@ static void fault_callback_scroll(u16, OSContext* p_context, u32, u32) {
*(u32*)(srr0 - 0x8), *(u32*)(srr0 - 0x4), *(u32*)srr0);
}
JUTGamePad pad(JUTGamePad::Port_1);
JUTGamePad pad(JUTGamePad::EPort1);
manager->setGamePad(&pad);
BOOL padDisabled = manager->isEnablePad() == false;
@@ -310,12 +310,12 @@ static void fault_callback_scroll(u16, OSContext* p_context, u32, u32) {
}
bool waitRetrace = false;
if (btnTrig == CButton::START) {
if (btnTrig == PAD_BUTTON_START) {
exception_addition(exConsole);
waitRetrace = true;
}
if (btnTrig == CButton::Z) {
if (btnTrig == PAD_TRIGGER_Z) {
JUTConsole* sysConsole = JFWSystem::getSystemConsole();
if (JUTConsoleManager::getManager()->getDirectConsole() != sysConsole) {
exConsole = sysConsole;
@@ -331,22 +331,22 @@ static void fault_callback_scroll(u16, OSContext* p_context, u32, u32) {
waitRetrace = true;
}
if (btnTrig == CButton::A) {
if (btnTrig == PAD_BUTTON_A) {
exConsole->scrollToLastLine();
waitRetrace = true;
}
if (btnTrig == CButton::B) {
if (btnTrig == PAD_BUTTON_B) {
exConsole->scrollToFirstLine();
waitRetrace = true;
}
if (btnHold == CButton::DPAD_UP) {
if (btnHold == PAD_BUTTON_UP) {
exConsole->scroll(holdUpCount < 3 ? -1 : (holdUpCount < 5 ? -2 : (holdUpCount < 7 ? -4 : -8)));
waitRetrace = true;
holdDownCount = 0;
holdUpCount++;
} else if (btnHold == CButton::DPAD_DOWN) {
} else if (btnHold == PAD_BUTTON_DOWN) {
exConsole->scroll(holdDownCount < 3 ? 1 : (holdDownCount < 5 ? 2 : (holdDownCount < 7 ? 4 : 8)));
waitRetrace = true;
holdUpCount = 0;
src/m_Do/m_Do_main.cpp
+19 -19
View File
@@ -97,8 +97,8 @@ void CheckHeap(u32 i_padNo) {
bool comboCheck = false;
// if L + R + Z is pressed
if ((mDoCPd_c::getHold(i_padNo) & ~CButton::Z) == (CButton::L + CButton::R) &&
mDoCPd_c::getTrig(i_padNo) & CButton::Z)
if ((mDoCPd_c::getHold(i_padNo) & ~PAD_TRIGGER_Z) == (PAD_TRIGGER_L + PAD_TRIGGER_R) &&
mDoCPd_c::getTrig(i_padNo) & PAD_TRIGGER_Z)
{
comboCheck = true;
}
@@ -276,7 +276,7 @@ bool Debug_console(u32 i_padNo) {
console_scroll_init = 1;
}
if (mDoCPd_c::getTrig(i_padNo) & CButton::Z && !(mDoCPd_c::getHold(i_padNo) & ~CButton::Z))
if (mDoCPd_c::getTrig(i_padNo) & PAD_TRIGGER_Z && !(mDoCPd_c::getHold(i_padNo) & ~PAD_TRIGGER_Z))
{
console->setVisible(console->isVisible() == false);
JUTAssertion::setMessageCount(0);
@@ -284,19 +284,19 @@ bool Debug_console(u32 i_padNo) {
if (console->isVisible()) {
u32 holdButtons = mDoCPd_c::getHold(i_padNo);
if ((holdButtons & CButton::L && holdButtons & CButton::R) ||
if ((holdButtons & PAD_TRIGGER_L && holdButtons & PAD_TRIGGER_R) ||
((mDoCPd_c::getAnalogL(i_padNo) > 0.0f && mDoCPd_c::getAnalogR(i_padNo) > 0.0f)))
{
f32 stick_x = mDoCPd_c::getStickX(i_padNo);
f32 stick_y = mDoCPd_c::getStickY(i_padNo);
if (holdButtons & (CButton::Y | CButton::X) &&
mDoCPd_c::getTrig(i_padNo) & CButton::START)
if (holdButtons & (PAD_BUTTON_Y | PAD_BUTTON_X) &&
mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_START)
{
console->clear();
}
if (!(mDoCPd_c::getHold(i_padNo) & (CButton::Y | CButton::X))) {
if (!(mDoCPd_c::getHold(i_padNo) & (PAD_BUTTON_Y | PAD_BUTTON_X))) {
console_scroll -= stick_y;
int scrollAmount;
@@ -313,16 +313,16 @@ bool Debug_console(u32 i_padNo) {
console->scroll(scrollAmount);
}
} else {
if (mDoCPd_c::getHold(i_padNo) & CButton::X) {
if (mDoCPd_c::getHold(i_padNo) & PAD_BUTTON_X) {
console_position_x += stick_x;
}
if (mDoCPd_c::getHold(i_padNo) & CButton::Y) {
if (mDoCPd_c::getHold(i_padNo) & PAD_BUTTON_Y) {
console_position_y -= stick_y;
}
}
if (mDoCPd_c::getTrig(i_padNo) & CButton::A) {
if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_A) {
console->dumpToTerminal(0xFFFFFFFF);
console->setOutput(JUTConsole::OUTPUT_OSREPORT | JUTConsole::OUTPUT_CONSOLE);
}
@@ -335,11 +335,11 @@ bool Debug_console(u32 i_padNo) {
} else {
u32 pressButtons = mDoCPd_c::getTrig(i_padNo);
if (pressButtons & CButton::DPAD_DOWN) {
if (pressButtons & PAD_BUTTON_DOWN) {
g_HIO.mDisplayMeter ^= 1;
}
if (pressButtons & CButton::DPAD_LEFT) {
if (pressButtons & PAD_BUTTON_LEFT) {
if (JKRAram::getAramHeap()) {
JKRAram::getAramHeap()->dump();
}
@@ -349,11 +349,11 @@ bool Debug_console(u32 i_padNo) {
g_dComIfG_gameInfo.mResControl.dump();
}
if (mDoCPd_c::getTrig(i_padNo) & CButton::DPAD_RIGHT) {
if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_RIGHT) {
JKRHeap::getSystemHeap()->dump_sort();
}
if (mDoCPd_c::getTrig(i_padNo) & CButton::DPAD_UP) {
if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_UP) {
zeldaHeap->dump_sort();
gameHeap->dump_sort();
archiveHeap->dump_sort();
@@ -391,15 +391,15 @@ static void debug() {
CheckHeap(PAD_3);
}
if ((mDoCPd_c::getGamePad(PAD_3)->getButton() & ~CButton::Z) == CButton::R &&
mDoCPd_c::getGamePad(PAD_3)->testTrigger(CButton::Z))
if ((mDoCPd_c::getGamePad(PAD_3)->getButton() & ~PAD_TRIGGER_Z) == PAD_TRIGGER_R &&
mDoCPd_c::getGamePad(PAD_3)->testTrigger(PAD_TRIGGER_Z))
{
mDisplayHeapSize ^= 1;
}
if (mDisplayHeapSize) {
if ((mDoCPd_c::getGamePad(PAD_3)->getButton() & ~CButton::Z) == CButton::L &&
mDoCPd_c::getGamePad(PAD_3)->testTrigger(CButton::Z))
if ((mDoCPd_c::getGamePad(PAD_3)->getButton() & ~PAD_TRIGGER_Z) == PAD_TRIGGER_L &&
mDoCPd_c::getGamePad(PAD_3)->testTrigger(PAD_TRIGGER_Z))
{
mDoMain::mHeapBriefType < 5 ? mDoMain::mHeapBriefType++ :
mDoMain::mHeapBriefType = 1;
@@ -647,4 +647,4 @@ JASAudioThread* JASGlobalInstance<JASAudioThread>::sInstance;
/* 80450B90-80450B98 000090 0004+04 0/0 4/4 0/0 .sbss
* sInstance__40JASGlobalInstance<19JASDefaultBankTable> */
JASDefaultBankTable* JASGlobalInstance<JASDefaultBankTable>::sInstance;
JASDefaultBankTable* JASGlobalInstance<JASDefaultBankTable>::sInstance;