mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-06-17 15:17:13 -04:00
Code Issues Packages Projects Releases Wiki Activity

move / fix bunch of stuff (#133)

Browse Source 
* fix some class structures / d_event wip

* d_event wip

* move gamepad stuff

* move m_Do_main

* move d_bomb / partial m_Do_reset

* format

* remove asm

* add Z2SoundID enum

* move some Z2 classes

* fix

* move more Z2 stuff

* fix fopAc_ac_c more
This commit is contained in:
TakaRikka
2021-06-12 15:22:36 -07:00
committed by GitHub
parent 5be309a186
commit 4448c08ac0
132 changed files with 6755 additions and 3217 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/m_Do/m_Do_controller_pad.cpp
+143 -44
View File
@@ -15,39 +15,6 @@ struct mDoRst {
static u8 mResetData[4 + 4 /* padding */];
};
struct interface_of_controller_pad {};
struct JUTGamePad {
struct EPadPort {};
struct CRumble {
/* 802E19D8 */ void setEnabled(u32);
};
struct C3ButtonReset {
static u8 sCallback[4];
static u8 sCallbackArg[4 + 4 /* padding */];
};
/* 802E06DC */ JUTGamePad(JUTGamePad::EPadPort);
/* 802E08E4 */ void read();
/* 802E1024 */ void clearForReset();
/* 802E199C */ void getGamePad(int);
static u8 sAnalogMode[4];
};
struct mDoCPd_c {
/* 80007954 */ void create();
/* 80007A94 */ void read();
/* 80007B7C */ void convert(interface_of_controller_pad*, JUTGamePad*);
/* 80007CD0 */ void LRlockCheck(interface_of_controller_pad*);
/* 80007D74 */ void recalibrate();
static u8 m_gamePad[16];
static u8 m_cpadInfo[256];
};
//
// Forward References:
//
@@ -72,7 +39,6 @@ extern "C" void read__10JUTGamePadFv();
extern "C" void clearForReset__10JUTGamePadFv();
extern "C" void getGamePad__10JUTGamePadFi();
extern "C" void setEnabled__Q210JUTGamePad7CRumbleFUl();
extern "C" void PADSetAnalogMode();
extern "C" void _savegpr_29();
extern "C" void _restgpr_29();
extern "C" extern u8 g_HIO[64 + 4 /* padding */];
@@ -89,12 +55,47 @@ extern "C" extern u8 struct_80451500[4];
/* ############################################################################################## */
/* 803DD2D8-803DD2E8 009FF8 0010+00 2/2 6/6 0/0 .bss m_gamePad__8mDoCPd_c */
u8 mDoCPd_c::m_gamePad[16];
JUTGamePad* mDoCPd_c::m_gamePad[4];
/* 803DD2E8-803DD3E8 00A008 0100+00 2/2 84/84 37/37 .bss m_cpadInfo__8mDoCPd_c */
u8 mDoCPd_c::m_cpadInfo[256];
interface_of_controller_pad mDoCPd_c::m_cpadInfo[4];
/* 80007954-80007A94 002294 0140+00 0/0 1/1 0/0 .text create__8mDoCPd_cFv */
#ifdef NONMATCHING
void mDoCPd_c::create() {
JUTGamePad* JUTGamePad_ptr;
cpadInfo* m_cpadInfo_addr;
JUTGamePad_ptr = new JUTGamePad(JUTGamePad::Port_1);
m_gamePad[0] = JUTGamePad_ptr;
if (lbl_80450580 == 0) {
m_gamePad[1] = NULL;
m_gamePad[2] = NULL;
m_gamePad[3] = NULL;
JUTGamePad_ptr = m_gamePad[3];
} else {
m_gamePad[1] = new JUTGamePad(JUTGamePad::Port_2);
m_gamePad[2] = new JUTGamePad(JUTGamePad::Port_3);
JUTGamePad_ptr = new JUTGamePad(JUTGamePad::Port_4);
}
m_gamePad[3] = JUTGamePad_ptr;
if (m_Do_Reset_NS_mDoRst_NS_mResetData->field_0x0 == 0) {
lbl_80451501 = false;
lbl_804514EC = resetCallBack__6mDoRstFiPv;
lbl_804514F0 = 0;
}
sAnalogMode = 3;
PADSetAnalogMode(3);
m_cpadInfo_addr = &m_cpadInfo;
for (int i = 4; i != 0; i--) {
m_cpadInfo_addr->interface.field_0x3a = false;
m_cpadInfo_addr->interface.field_0x39 = false;
m_cpadInfo_addr->interface.field_0x3c = false;
m_cpadInfo_addr->interface.field_0x3b = false;
m_cpadInfo_addr = m_cpadInfo_addr->unk1;
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -103,8 +104,40 @@ asm void mDoCPd_c::create() {
#include "asm/m_Do/m_Do_controller_pad/create__8mDoCPd_cFv.s"
}
#pragma pop
#endif
/* 80007A94-80007B7C 0023D4 00E8+00 0/0 1/1 0/0 .text read__8mDoCPd_cFv */
#ifdef NONMATCHING
void mDoCPd_c::read() {
//_savegpr_29();
gamePad->read();
if (m_Do_Reset_NS_mDoRst_NS_mResetData->field_0x0 == 0 &&
m_Do_Reset_NS_mDoRst_NS_mResetData->field_0x8 != 0) {
JUTGamePad* JUTGamePad_ptr =
JUTGamePad::getGamePad(m_Do_Reset_NS_mDoRst_NS_mResetData->pad_index);
bool error = false;
if (JUTGamePad_ptr->pad_port != 0xffff &&
JUTGamePad_ptr->rumble.field_0x10 != 0) { // Make the rumble thing right
error = true;
}
if (error = false) {
m_Do_Reset_NS_mDoRst_NS_mResetData->field_0x8 = 0;
}
}
JUTGamePad** m_gamePad_ptr = m_gamePad;
cpadInfo* cpad_ptr = &m_cpadInfo;
for (int i = 0; i < 4; i++) {
if (*m_gamePad_ptr == 0) {
cLib_memSet(cpad_ptr, 0, 0x40);
} else {
convert(&cpad_ptr->interface, *m_gamePad_ptr);
LRlockCheck(&cpad_ptr->interface);
}
m_gamePad_ptr = m_gamePad_ptr + 1; // Shouldn't it be 4 if it's incrementing a pointer???
cpad_ptr = cpad_ptr->unk1;
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -113,6 +146,7 @@ asm void mDoCPd_c::read() {
#include "asm/m_Do/m_Do_controller_pad/read__8mDoCPd_cFv.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 80451A20-80451A24 000020 0004+00 1/1 0/0 0/0 .sdata2 @3709 */
@@ -133,6 +167,44 @@ SECTION_SDATA2 static f64 lit_3713 = 4503599627370496.0 /* cast u32 to float */;
/* 80007B7C-80007CD0 0024BC 0154+00 1/1 0/0 0/0 .text
* convert__8mDoCPd_cFP27interface_of_controller_padP10JUTGamePad */
#ifdef NONMATCHING
// off on load order, regalloc, const placement (int-to-float conversion magic).
void mDoCPd_c::convert(interface_of_controller_pad* pInterface, JUTGamePad* pPad) {
pInterface->mButtonFlags = pPad->buttons.mButtonFlags;
pInterface->mPressedButtonFlags = pPad->buttons.mPressedButtonFlags;
pInterface->mMainStickPosX = pPad->control_stick.mPosX;
pInterface->mMainStickPosY = pPad->control_stick.mPosY;
pInterface->mMainStickValue = pPad->control_stick.mValue;
pInterface->mMainStickAngle = pPad->control_stick.mAngle;
pInterface->mCStickPosX = pPad->c_stick.mPosX;
pInterface->mCStickPosY = pPad->c_stick.mPosY;
pInterface->mCStickValue = pPad->c_stick.mValue;
pInterface->mCStickAngle = pPad->c_stick.mAngle;
pInterface->mAnalogA = lbl_80451A20 * pPad->buttons.mAnalogARaw;
if (pInterface->mAnalogA > lbl_80451A24 /* 1.0 */) {
pInterface->mAnalogA = lbl_80451A24;
}
pInterface->mAnalogB = lbl_80451A20 * pPad->buttons.mAnalogBRaw;
if (pInterface->mAnalogB > lbl_80451A24 /* 1.0 */) {
pInterface->mAnalogB = lbl_80451A24;
}
// pInterface->mTriggerLeft = pPad->buttons.mTriggerLeftRaw * (1/140.0f);
pInterface->mTriggerLeft = lbl_80451A28 * pPad->buttons.mTriggerLeftRaw;
if (pInterface->mTriggerLeft > lbl_80451A24 /* 1.0 */) {
pInterface->mTriggerLeft = lbl_80451A24;
}
pInterface->mTriggerRight = lbl_80451A28 * pPad->buttons.mTriggerRightRaw;
if (pInterface->mTriggerRight > lbl_80451A24 /* 1.0 */) {
pInterface->mTriggerRight = lbl_80451A24;
}
pInterface->mGamepadErrorFlags = pPad->error_value;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -141,9 +213,39 @@ asm void mDoCPd_c::convert(interface_of_controller_pad* param_0, JUTGamePad* par
#include "asm/m_Do/m_Do_controller_pad/convert__8mDoCPd_cFP27interface_of_controller_padP10JUTGamePad.s"
}
#pragma pop
#endif
/* 80007CD0-80007D74 002610 00A4+00 1/1 0/0 0/0 .text
* LRlockCheck__8mDoCPd_cFP27interface_of_controller_pad */
#ifdef NONMATCHING
void mDoCPd_c::LRlockCheck(interface_of_controller_pad* controllerInterface) {
float temp_1 = controllerInterface->trigger_left; // not sure if temp is left or right
controllerInterface->field_0x3a = false;
controllerInterface->field_0x3c = false;
if (temp_1 <= g_HIO.float_global_1) { // controllerInterface->trigger_left) {
if (temp_1 < g_HIO.float_global_2) {
controllerInterface->field_0x39 = false;
}
} else {
if (controllerInterface->field_0x39 == false) {
controllerInterface->field_0x3a = true;
}
controllerInterface->field_0x39 = true;
}
if (controllerInterface->trigger_right > g_HIO.float_global_1) {
if (controllerInterface->field_0x3b == false) {
controllerInterface->field_0x3c = true;
}
controllerInterface->field_0x3b = true;
return;
}
if (controllerInterface->trigger_right >= g_HIO.float_global_2) {
return;
}
controllerInterface->field_0x3b = false;
return;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -152,13 +254,10 @@ asm void mDoCPd_c::LRlockCheck(interface_of_controller_pad* param_0) {
#include "asm/m_Do/m_Do_controller_pad/LRlockCheck__8mDoCPd_cFP27interface_of_controller_pad.s"
}
#pragma pop
#endif
/* 80007D74-80007D9C 0026B4 0028+00 0/0 1/1 0/0 .text recalibrate__8mDoCPd_cFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void mDoCPd_c::recalibrate() {
nofralloc
#include "asm/m_Do/m_Do_controller_pad/recalibrate__8mDoCPd_cFv.s"
void mDoCPd_c::recalibrate(void) {
JUTGamePad::clearForReset();
JUTGamePad::CRumble::setEnabled(
PADMask(PAD_CHAN3_BIT | PAD_CHAN2_BIT | PAD_CHAN1_BIT | PAD_CHAN0_BIT));
}
#pragma pop