mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-08-17 21:33:42 -04:00
Code Issues Packages Projects Releases Wiki Activity

npcT / JUTGamePad work

Browse Source
This commit is contained in:
TakaRikka
2022-05-28 03:49:55 -07:00
parent 9bcbccbeb5
commit 36e62e0b80
52 changed files with 1245 additions and 1189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/JSystem/JUtility/JUTGamePad.cpp
+389 -311
View File
@@ -6,10 +6,7 @@
#include "JSystem/JUtility/JUTGamePad.h"
#include "dol2asm.h"
#include "dolphin/types.h"
// can't type mPadList correctly because of __sinit
// remove this once __sinit is decompiled
#define mPadListHack (*(JSUList<JUTGamePad>*)&mPadList)
#include "MSL_C/math.h"
//
// Forward References:
@@ -90,7 +87,7 @@ extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void OSGetResetSwitchState();
extern "C" s32 OSGetResetSwitchState();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void _savegpr_22();
@@ -101,8 +98,6 @@ extern "C" void _restgpr_22();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
extern "C" void atan2();
extern "C" extern u32 __float_nan;
//
// Declarations:
@@ -120,69 +115,52 @@ SECTION_DATA PADMask 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};
/* 803CC610-803CC620 029730 000C+04 2/2 0/0 0/0 .data __vt__10JUTGamePad */
SECTION_DATA extern void* __vt__10JUTGamePad[3 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__10JUTGamePadFv,
/* padding */
NULL,
};
/* 804343D8-804343E4 0610F8 000C+00 3/3 0/0 0/0 .bss @525 */
static u8 lit_525[12];
/* 804343E4-804343F0 061104 000C+00 4/6 0/0 0/0 .bss mPadList__10JUTGamePad */
u8 JUTGamePad::mPadList[12];
JSUList<JUTGamePad> JUTGamePad::mPadList(false);
/* 804514D0-804514D4 0009D0 0004+00 1/1 0/0 0/0 .sbss None */
static bool data_804514D0;
bool JUTGamePad::mListInitialized;
/* 804514D4-804514D8 0009D4 0004+00 3/3 0/0 0/0 .sbss mPadAssign__10JUTGamePad */
u8 JUTGamePad::mPadAssign[4];
/* 802E06DC-802E07B0 2DB01C 00D4+00 0/0 4/4 0/0 .text __ct__10JUTGamePadFQ210JUTGamePad8EPadPort
*/
#ifdef NONMATCHING
// TODO(erin): probably ~easy to do, i just didn't do it yet :)
JUTGamePad::JUTGamePad(EPadPort port) : ptr_link(this) {
this->buttons.clear();
this->control_stick.clear();
this->c_stick.clear();
this->rumble.clear();
JUTGamePad::JUTGamePad(EPadPort port) : mRumble(this), mLink(this) {
mPortNum = port;
if (mPortNum >= 0) {
mPadAssign[port]++;
}
initList();
mPadList.append(&mLink);
update();
mPadRecord = 0;
mPadReplay = 0;
clear();
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JUTGamePad::JUTGamePad(JUTGamePad::EPadPort param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/__ct__10JUTGamePadFQ210JUTGamePad8EPadPort.s"
}
#pragma pop
#endif
/* 802E07B0-802E085C 2DB0F0 00AC+00 1/0 2/2 0/0 .text __dt__10JUTGamePadFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JUTGamePad::~JUTGamePad() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/__dt__10JUTGamePadFv.s"
JUTGamePad::~JUTGamePad() {
if (mPortNum >= 0) {
mPadAssign[mPortNum]--;
mPortNum = -1;
}
mPadList.remove(&mLink);
}
#pragma pop
/* 802E085C-802E0898 2DB19C 003C+00 1/1 0/0 0/0 .text initList__10JUTGamePadFv */
void JUTGamePad::initList() {
if (/* mIsPadListInitialized */ data_804514D0 == false) {
mPadListHack.initiate();
data_804514D0 = true;
if (!mListInitialized) {
mPadList.initiate();
mListInitialized = true;
}
}
/* ############################################################################################## */
/* 804514D8-804514DC 0009D8 0004+00 2/2 0/0 0/0 .sbss sSuppressPadReset__10JUTGamePad */
u8 JUTGamePad::sSuppressPadReset[4];
u32 JUTGamePad::sSuppressPadReset;
/* 804514DC-804514E0 0009DC 0004+00 1/1 1/1 0/0 .sbss sAnalogMode__10JUTGamePad */
s32 JUTGamePad::sAnalogMode;
@@ -190,9 +168,7 @@ s32 JUTGamePad::sAnalogMode;
/* 802E0898-802E08D0 2DB1D8 0038+00 0/0 1/1 0/0 .text init__10JUTGamePadFv */
s32 JUTGamePad::init() {
PADSetSpec(5);
sAnalogMode = 3;
PADSetAnalogMode(3);
setAnalogMode(3);
return PADInit();
}
@@ -207,22 +183,22 @@ void JUTGamePad::clear() {
PADStatus JUTGamePad::mPadStatus[4];
/* 80434420-804344E0 061140 00C0+00 1/4 0/0 0/0 .bss mPadButton__10JUTGamePad */
u8 JUTGamePad::mPadButton[192];
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
u8 JUTGamePad::mPadMStick[64];
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
u8 JUTGamePad::mPadSStick[64];
JUTGamePad::CStick JUTGamePad::mPadSStick[4];
#pragma pop
/* 804508D8-804508DC 000358 0004+00 1/1 0/0 0/0 .sdata sStickMode__10JUTGamePad */
SECTION_SDATA u32 JUTGamePad::sStickMode = 0x00000001;
SECTION_SDATA JUTGamePad::EStickMode JUTGamePad::sStickMode = STICK_MODE_1;
/* 804508DC-804508E0 00035C 0004+00 2/2 0/0 0/0 .sdata sClampMode__10JUTGamePad */
SECTION_SDATA u32 JUTGamePad::sClampMode = 0x00000001;
@@ -231,47 +207,96 @@ SECTION_SDATA u32 JUTGamePad::sClampMode = 0x00000001;
u32 JUTGamePad::sRumbleSupported;
/* 802E08E4-802E0BBC 2DB224 02D8+00 0/0 2/2 0/0 .text read__10JUTGamePadFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::read() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/read__10JUTGamePadFv.s"
}
#pragma pop
#ifdef NONMATCHING
u32 JUTGamePad::read() {
sRumbleSupported = PADRead(mPadStatus);
/* 802E0BBC-802E0C6C 2DB4FC 00B0+00 1/1 0/0 0/0 .text assign__10JUTGamePadFv */
#if 0
// matches if all static variables have their proper type
void JUTGamePad::assign() {
s32 iVar3 = 0;
switch (sClampMode) {
case 1:
PADClamp(mPadStatus);
break;
case 2:
PADClampCircle(mPadStatus);
break;
}
for (s32 i = 4; i > 0; i--) {
if ((/* mPadStatus */ lbl_804343F0[iVar3].error == 0) &&
(/* *puVar2 */ lbl_804514D4[iVar3] == 0)) {
mPortNum = iVar3;
/* JUTGamePad::mPadAssign[iVar3] */ /* *puVar2 */ lbl_804514D4[iVar3] = 1;
/* JUTGamePad::mPadButton */ lbl_80434420[iVar3].setRepeat(
this->buttons.field_0x24, this->buttons.field_0x28, this->buttons.field_0x2c);
this->rumble.clear(this);
u32 mask = 0;
for (int i = 0; i < 4; i++) {
u32 mask_tmp = 0x80000000 >> 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;
u32 tmp = m_stick | s_stick;
mPadButton[i].update(&mPadStatus[i], tmp);
} 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);
mPadButton[i].update(NULL, 0);
return;
if (!(sSuppressPadReset & mask_tmp)) {
mask |= mask_tmp;
}
} else {
mPadButton[i].mTrigger = 0;
mPadButton[i].mRelease = 0;
mPadButton[i].mRepeat = 0;
}
}
JSUListIterator<JUTGamePad> pad(mPadList.getFirst());
for (; pad != mPadList.getEnd(); pad++) {
if (pad->getPadReplay() && pad->getPadReplay()->mActive) {
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;
pad->mButton.update(&status, m_stick | s_stick);
} else {
if (pad->mPortNum == -1) {
pad->assign();
}
pad->update();
}
iVar3++;
if (pad->getPadRecord() && pad->getPadRecord()->mActive) {
s32 portNum = pad->mPortNum;
if (portNum >= 0 && mPadStatus[portNum].error == 0) {
pad->getPadRecord()->unk2();
}
}
}
if (mask != 0) {
PADReset((PADMask)mask);
}
checkResetSwitch();
return sRumbleSupported;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::assign() {
asm u32 JUTGamePad::read() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/assign__10JUTGamePadFv.s"
#include "asm/JSystem/JUtility/JUTGamePad/read__10JUTGamePadFv.s"
}
#pragma pop
#endif
/* 802E0BBC-802E0C6C 2DB4FC 00B0+00 1/1 0/0 0/0 .text assign__10JUTGamePadFv */
void JUTGamePad::assign() {
for (int i = 0; i < 4; i++) {
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);
mRumble.clear(this);
return;
}
}
}
/* ############################################################################################## */
/* 804514E4-804514E8 0009E4 0004+00 5/5 0/0 0/0 .sbss mStatus__Q210JUTGamePad7CRumble */
bool JUTGamePad::CRumble::mStatus[4];
@@ -287,7 +312,7 @@ 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 JUTGamePad::C3ButtonReset::sThreshold = (OSTime)((OS_BUS_CLOCK / 4) / 60) * 30;
/* 80451500-80451504 -00001 0004+00 3/3 6/6 0/0 .sbss None */
/* 80451500 0001+00 data_80451500 None */
@@ -301,27 +326,22 @@ s32 JUTGamePad::C3ButtonReset::sResetOccurredPort;
/* 802E0C6C-802E0CD8 2DB5AC 006C+00 1/1 1/1 0/0 .text checkResetCallback__10JUTGamePadFx
*/
void JUTGamePad::checkResetCallback(OSTime unk) {
if (unk < JUTGamePad::C3ButtonReset::sThreshold)
void JUTGamePad::checkResetCallback(OSTime holdTime) {
if (holdTime < JUTGamePad::C3ButtonReset::sThreshold) {
return;
}
struct_80451501 = true;
JUTGamePad::C3ButtonReset::sResetOccurredPort = mPortNum;
if (JUTGamePad::C3ButtonReset::sCallback != NULL) {
JUTGamePad::C3ButtonReset::sCallback(mPortNum, JUTGamePad::C3ButtonReset::sCallbackArg);
}
}
/* ############################################################################################## */
/* 80434560-8043456C 061280 000C+00 0/1 0/0 0/0 .bss @1373 */
#pragma push
#pragma force_active on
static u8 lit_1373[12];
#pragma pop
/* 8043456C-80434578 06128C 000C+00 1/2 0/0 0/0 .bss sPatternList__19JUTGamePadLongPress
*/
u8 JUTGamePadLongPress::sPatternList[12];
JSUList<JUTGamePadLongPress> JUTGamePadLongPress::sPatternList(false);
/* 804508E0-804508E4 000360 0004+00 1/1 0/0 0/0 .sdata sPressPoint__Q210JUTGamePad6CStick
*/
@@ -339,6 +359,51 @@ SECTION_SDATA u32 JUTGamePad::C3ButtonReset::sResetPattern = 0x00001600;
SECTION_SDATA 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 >= 0 && mPortNum < 4) {
mButton = mPadButton[mPortNum];
mMainStick = mPadMStick[mPortNum];
mSubStick = mPadSStick[mPortNum];
mErrorStatus = mPadStatus[mPortNum].error;
}
if (field_0xa8 == 0 || (mButton.mButton & C3ButtonReset::sResetMaskPattern) != C3ButtonReset::sResetPattern) {
mButtonReset.mReset = false;
} else if (!struct_80451501) {
if (mButtonReset.mReset == true) {
checkResetCallback(OSGetTime() - mResetTime);
} else {
mButtonReset.mReset = true;
mResetTime = OSGetTime();
}
}
JSUListIterator<JUTGamePadLongPress> pad(JUTGamePadLongPress::sPatternList.getFirst());
for (; pad != JUTGamePadLongPress::sPatternList.getEnd(); pad++) {
if (pad->mValid) {
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]);
} else {
pad->field_0x20[mPortNum] = true;
pad->mTimer[mPortNum] = OSGetTime();
}
} else {
pad->field_0x20[mPortNum] = false;
}
}
}
}
if (mPortNum >= 0 && mPortNum < 4) {
mRumble.update(mPortNum);
}
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -347,164 +412,225 @@ asm void JUTGamePad::update() {
#include "asm/JSystem/JUtility/JUTGamePad/update__10JUTGamePadFv.s"
}
#pragma pop
#endif
/* 802E0FA4-802E1024 2DB8E4 0080+00 1/1 0/0 0/0 .text checkResetSwitch__10JUTGamePadFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::checkResetSwitch() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/checkResetSwitch__10JUTGamePadFv.s"
void JUTGamePad::checkResetSwitch() {
if (!struct_80451501) {
if (OSGetResetSwitchState()) {
struct_80451500 = true;
} else {
if (struct_80451500 == true) {
struct_80451501 = true;
C3ButtonReset::sResetOccurredPort = -1;
if (C3ButtonReset::sCallback != NULL) {
C3ButtonReset::sCallback(-1, C3ButtonReset::sCallbackArg);
}
}
struct_80451500 = false;
}
}
}
#pragma pop
/* 802E1024-802E1050 2DB964 002C+00 0/0 1/1 0/0 .text clearForReset__10JUTGamePadFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::clearForReset() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/clearForReset__10JUTGamePadFv.s"
void JUTGamePad::clearForReset() {
CRumble::setEnabled(0);
recalibrate(PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT);
}
#pragma pop
/* 802E1050-802E108C 2DB990 003C+00 2/2 0/0 0/0 .text clear__Q210JUTGamePad7CButtonFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CButton::clear() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/clear__Q210JUTGamePad7CButtonFv.s"
void JUTGamePad::CButton::clear() {
mButton = 0;
mTrigger = 0;
mRelease = 0;
mRepeat = 0;
mAnalogA = 0;
mAnalogB = 0;
mAnalogL = 0;
mAnalogR = 0;
field_0x1c = 0;
field_0x20 = 0;
field_0x24 = 0;
field_0x28 = 0;
field_0x2c = 0;
}
#pragma pop
/* ############################################################################################## */
/* 80456018-80456020 004618 0004+04 1/1 0/0 0/0 .sdata2 @1047 */
SECTION_SDATA2 static f32 lit_1047[1 + 1 /* padding */] = {
150.0f,
/* padding */
0.0f,
};
/* 80456020-80456028 004620 0008+00 2/2 0/0 0/0 .sdata2 @1050 */
SECTION_SDATA2 static f64 lit_1050 = 4503601774854144.0 /* cast s32 to float */;
/* 802E108C-802E121C 2DB9CC 0190+00 1/1 0/0 0/0 .text
* update__Q210JUTGamePad7CButtonFPC9PADStatusUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm u32 JUTGamePad::CButton::update(PADStatus const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/update__Q210JUTGamePad7CButtonFPC9PADStatusUl.s"
}
#pragma pop
void JUTGamePad::CButton::update(PADStatus const* padStatus, u32 stickStatus) {
u32 buttons;
if (padStatus != NULL) {
buttons = padStatus->button;
} else {
buttons = 0;
}
buttons = stickStatus | buttons;
mRepeat = 0;
if (field_0x28 != 0 && field_0x24 != 0) {
u32 repeatButton = buttons & field_0x24;
mRepeat = 0;
if (repeatButton == 0) {
field_0x20 = 0;
field_0x1c = 0;
} else if (field_0x20 == repeatButton) {
field_0x1c++;
if (field_0x1c == field_0x28 || (field_0x1c > field_0x28 && (field_0x1c - field_0x28) % field_0x2c == 0)) {
mRepeat = repeatButton;
}
} else {
mRepeat = repeatButton & (field_0x20 ^ 0xFFFFFFFF);
field_0x20 = repeatButton;
field_0x1c = 0;
}
}
/* ############################################################################################## */
/* 80456028-80456030 004628 0004+04 2/2 0/0 0/0 .sdata2 @1056 */
SECTION_SDATA2 static f32 lit_1056[1 + 1 /* padding */] = {
0.0f,
/* padding */
0.0f,
};
mTrigger = buttons & (buttons ^ mButton);
mRelease = mButton & (buttons ^ mButton);
mButton = buttons;
mRepeat |= (field_0x24 ^ 0xFFFFFFFF) & mTrigger;
if (padStatus != NULL) {
mAnalogA = padStatus->analog_a;
mAnalogB = padStatus->analog_b;
mAnalogL = padStatus->trigger_left;
mAnalogR = padStatus->trigger_right;
} else {
mAnalogA = 0;
mAnalogB = 0;
mAnalogL = 0;
mAnalogR = 0;
}
mAnalogLf = (s32)mAnalogL / 150.0f;
mAnalogRf = (s32)mAnalogR / 150.0f;
}
/* 802E121C-802E1238 2DBB5C 001C+00 2/2 0/0 0/0 .text clear__Q210JUTGamePad6CStickFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CStick::clear() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/clear__Q210JUTGamePad6CStickFv.s"
void JUTGamePad::CStick::clear() {
mPosX = 0.0f;
mPosY = 0.0f;
mValue = 0.0f;
mAngle = 0;
}
#pragma pop
/* ############################################################################################## */
/* 80456030-80456038 004630 0008+00 1/1 0/0 0/0 .sdata2 @1117 */
SECTION_SDATA2 static f64 lit_1117 = 0.5;
/* 80456038-80456040 004638 0008+00 1/1 0/0 0/0 .sdata2 @1118 */
SECTION_SDATA2 static f64 lit_1118 = 3.0;
/* 80456040-80456048 004640 0008+00 1/1 0/0 0/0 .sdata2 @1119 */
SECTION_SDATA2 static u8 lit_1119[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/* 80456048-8045604C 004648 0004+00 1/1 0/0 0/0 .sdata2 @1120 */
SECTION_SDATA2 static f32 lit_1120 = 1.0f;
/* 8045604C-80456050 00464C 0004+00 1/1 0/0 0/0 .sdata2 @1121 */
SECTION_SDATA2 static f32 lit_1121 = 10430.37890625f;
/* 802E1238-802E1500 2DBB78 02C8+00 1/1 0/0 0/0 .text
* update__Q210JUTGamePad6CStickFScScQ210JUTGamePad10EStickModeQ210JUTGamePad11EWhichStickUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm u32 JUTGamePad::CStick::update(s8 param_0, s8 param_1, JUTGamePad::EStickMode param_2,
JUTGamePad::EWhichStick param_3, u32 param_4) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/func_802E1238.s"
u32 JUTGamePad::CStick::update(s8 x_val, s8 y_val, JUTGamePad::EStickMode mode,
JUTGamePad::EWhichStick stick, u32 buttons) {
s32 clamp;
switch (sClampMode) {
case 1:
clamp = stick == WS_MAIN_STICK ? 54 : 42;
break;
case 2:
clamp = stick == WS_MAIN_STICK ? 38 : 29;
break;
default:
clamp = stick == WS_MAIN_STICK ? 69 : 57;
break;
}
field_0xe = x_val;
field_0xf = y_val;
mPosX = (f32)x_val / (f32)clamp;
mPosY = (f32)y_val / (f32)clamp;
mValue = sqrtf((mPosX * mPosX) + (mPosY * mPosY));
if (mValue > 1.0f) {
if (mode == STICK_MODE_1) {
mPosX /= mValue;
mPosY /= mValue;
}
mValue = 1.0f;
}
if (mValue > 0.0f) {
if (mPosY == 0.0f) {
if (mPosX > 0.0f) {
mAngle = 0x4000;
} else {
mAngle = -0x4000;
}
} else {
mAngle = 10430.379f * atan2f(mPosX, -mPosY);
}
}
u32 buttonType = stick == WS_MAIN_STICK ? 0x18 : 0x10;
return getButton(buttons >> buttonType);
}
#pragma pop
/* 802E1500-802E15B4 2DBE40 00B4+00 1/1 0/0 0/0 .text getButton__Q210JUTGamePad6CStickFUl
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm u32 JUTGamePad::CStick::getButton(u32 param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/getButton__Q210JUTGamePad6CStickFUl.s"
u32 JUTGamePad::CStick::getButton(u32 buttons) {
u32 button = buttons & 0xF;
if (-sReleasePoint < mPosX && mPosX < sReleasePoint) {
button = button & 0xFFFFFFFC;
} else if (mPosX <= -sPressPoint) {
button = (button & 0xFFFFFFFD) | 1;
} else if (mPosX >= sPressPoint) {
button = (button & 0xFFFFFFFE) | 2;
}
if (-sReleasePoint < mPosY && mPosY < sReleasePoint) {
button = button & 0xFFFFFFF3;
} else if (mPosY <= -sPressPoint) {
button = (button & 0xFFFFFFF7) | 4;
} else if (mPosY >= sPressPoint) {
button = (button & 0xFFFFFFFB) | 8;
}
return button;
}
#pragma pop
/* 802E15B4-802E15D8 2DBEF4 0024+00 1/1 0/0 0/0 .text clear__Q210JUTGamePad7CRumbleFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::clear() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/clear__Q210JUTGamePad7CRumbleFv.s"
void JUTGamePad::CRumble::clear() {
field_0x0 = 0;
field_0x4 = 0;
field_0x8 = 0;
field_0xc = 0;
field_0x10 = 0;
mEnabled = (PADMask)(PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT);
}
#pragma pop
/* 802E15D8-802E1634 2DBF18 005C+00 2/2 0/0 0/0 .text clear__Q210JUTGamePad7CRumbleFP10JUTGamePad
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::clear(JUTGamePad* param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/clear__Q210JUTGamePad7CRumbleFP10JUTGamePad.s"
void JUTGamePad::CRumble::clear(JUTGamePad* pad) {
if (pad->getPortNum() >= 0 && pad->getPortNum() < 4) {
mStatus[pad->getPortNum()] = false;
pad->stopMotorHard();
}
clear();
}
#pragma pop
/* 802E1634-802E168C 2DBF74 0058+00 1/1 0/0 0/0 .text startMotor__Q210JUTGamePad7CRumbleFi */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::startMotor(int param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/startMotor__Q210JUTGamePad7CRumbleFi.s"
void JUTGamePad::CRumble::startMotor(int portNo) {
if (isEnabledPort(portNo)) {
PADControlMotor(portNo, 1);
mStatus[portNo] = true;
}
}
#pragma pop
/* 802E168C-802E16F8 2DBFCC 006C+00 4/4 3/3 0/0 .text stopMotor__Q210JUTGamePad7CRumbleFib */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::stopMotor(int param_0, bool param_1) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/stopMotor__Q210JUTGamePad7CRumbleFib.s"
void JUTGamePad::CRumble::stopMotor(int portNo, bool stop) {
if (isEnabledPort(portNo)) {
u8 command = stop ? 2 : 0;
PADControlMotor(portNo, command);
mStatus[portNo] = false;
}
}
#pragma pop
/* 802E16F8-802E1720 2DC038 0028+00 1/1 0/0 0/0 .text getNumBit__FPUci */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void getNumBit(u8* param_0, int param_1) {
static asm u8 getNumBit(u8* param_0, int param_1) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/getNumBit__FPUci.s"
}
@@ -522,14 +648,12 @@ asm void JUTGamePad::CRumble::update(s16 param_0) {
/* 802E18A4-802E18CC 2DC1E4 0028+00 1/1 0/0 0/0 .text
* triggerPatternedRumble__Q210JUTGamePad7CRumbleFUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::triggerPatternedRumble(u32 param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/triggerPatternedRumble__Q210JUTGamePad7CRumbleFUl.s"
void JUTGamePad::CRumble::triggerPatternedRumble(u32 param_0) {
if (field_0x8 != NULL && field_0xc != 0) {
field_0x4 = param_0;
field_0x0 = 0;
}
}
#pragma pop
/* 802E18CC-802E1948 2DC20C 007C+00 0/0 2/2 0/0 .text
* startPatternedRumble__Q210JUTGamePad7CRumbleFPvQ310JUTGamePad7CRumble7ERumbleUl */
@@ -546,14 +670,10 @@ asm void JUTGamePad::CRumble::startPatternedRumble(void* param_0,
/* 802E1948-802E1978 2DC288 0030+00 1/1 3/3 0/0 .text
* stopPatternedRumble__Q210JUTGamePad7CRumbleFs */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::stopPatternedRumble(s16 param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/stopPatternedRumble__Q210JUTGamePad7CRumbleFs.s"
void JUTGamePad::CRumble::stopPatternedRumble(s16 port) {
field_0x4 = 0;
stopMotor(port, true);
}
#pragma pop
/* 802E1978-802E199C 2DC2B8 0024+00 0/0 1/1 0/0 .text
* stopPatternedRumbleAtThePeriod__Q210JUTGamePad7CRumbleFv */
@@ -567,106 +687,64 @@ asm void JUTGamePad::CRumble::stopPatternedRumbleAtThePeriod() {
#pragma pop
/* 802E199C-802E19D8 2DC2DC 003C+00 1/1 1/1 0/0 .text getGamePad__10JUTGamePadFi */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JUTGamePad* JUTGamePad::getGamePad(int param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/getGamePad__10JUTGamePadFi.s"
JUTGamePad* JUTGamePad::getGamePad(int padNo) {
JSUListIterator<JUTGamePad> pad(mPadList.getFirst());
for (; pad != mPadList.getEnd(); pad++) {
if (padNo == pad->mPortNum) {
return pad.getObject();
}
}
return NULL;
}
#pragma pop
/* 802E19D8-802E1A7C 2DC318 00A4+00 1/1 1/1 0/0 .text setEnabled__Q210JUTGamePad7CRumbleFUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CRumble::setEnabled(u32 param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/setEnabled__Q210JUTGamePad7CRumbleFUl.s"
void JUTGamePad::CRumble::setEnabled(u32 mask) {
for (int i = 0; i < 4; i++) {
if ((mEnabled & channel_mask[i]) == 0) {
if (mStatus[i]) {
stopMotor(i, false);
}
JUTGamePad* pad = getGamePad(i);
if (pad != NULL) {
pad->mRumble.stopPatternedRumble(pad->mPortNum);
}
}
}
mEnabled = (PADMask)(mask & (PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT));
}
#pragma pop
/* 802E1A7C-802E1A98 2DC3BC 001C+00 1/1 0/0 0/0 .text setRepeat__Q210JUTGamePad7CButtonFUlUlUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePad::CButton::setRepeat(u32 param_0, u32 param_1, u32 param_2) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/setRepeat__Q210JUTGamePad7CButtonFUlUlUl.s"
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;
}
#pragma pop
/* 802E1A98-802E1AFC 2DC3D8 0064+00 1/1 0/0 0/0 .text recalibrate__10JUTGamePadFUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool JUTGamePad::recalibrate(u32 param_0) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/recalibrate__10JUTGamePadFUl.s"
bool JUTGamePad::recalibrate(u32 mask) {
for (int i = 0; i < 4; i++) {
if (sSuppressPadReset & channel_mask[i]) {
mask &= channel_mask[i] ^ 0xFFFFFFFF;
}
}
return PADRecalibrate((PADMask)mask);
}
#pragma pop
/* 802E1AFC-802E1B60 2DC43C 0064+00 1/1 0/0 0/0 .text checkCallback__19JUTGamePadLongPressFiUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTGamePadLongPress::checkCallback(int param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/checkCallback__19JUTGamePadLongPressFiUl.s"
}
#pragma pop
void JUTGamePadLongPress::checkCallback(int port, u32 timer) {
if (port >= 0 && timer >= field_0x1c) {
field_0x11 = true;
field_0x48[port] = true;
/* 802E1B60-802E1C54 2DC4A0 00F4+00 0/0 1/0 0/0 .text __sinit_JUTGamePad_cpp */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __sinit_JUTGamePad_cpp() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/__sinit_JUTGamePad_cpp.s"
if (mCallback != NULL) {
mCallback(port, this, field_0x50);
}
}
}
#pragma pop
#pragma push
#pragma force_active on
REGISTER_CTORS(0x802E1B60, __sinit_JUTGamePad_cpp);
#pragma pop
/* 802E1C54-802E1CA8 2DC594 0054+00 1/1 0/0 0/0 .text __dt__30JSUList<19JUTGamePadLongPress>Fv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
extern "C" asm void func_802E1C54(void* _this) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/func_802E1C54.s"
}
#pragma pop
/* 802E1CA8-802E1CD8 2DC5E8 0030+00 1/1 0/0 0/0 .text __ct__Q210JUTGamePad6CStickFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JUTGamePad::CStick::CStick() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/__ct__Q210JUTGamePad6CStickFv.s"
}
#pragma pop
/* 802E1CD8-802E1D08 2DC618 0030+00 1/1 0/0 0/0 .text __ct__Q210JUTGamePad7CButtonFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JUTGamePad::CButton::CButton() {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/__ct__Q210JUTGamePad7CButtonFv.s"
}
#pragma pop
/* 802E1D08-802E1D5C 2DC648 0054+00 1/1 0/0 0/0 .text __dt__21JSUList<10JUTGamePad>Fv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
extern "C" asm void func_802E1D08(void* _this) {
nofralloc
#include "asm/JSystem/JUtility/JUTGamePad/func_802E1D08.s"
}
#pragma pop