mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-09-03 02:03:55 -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_Reset.cpp
+104 -25
View File
@@ -5,18 +5,13 @@
#include "m_Do/m_Do_Reset.h"
#include "dol2asm.h"
#include "dolphin/gx/GX.h"
#include "dolphin/types.h"
//
// Types:
//
struct mDoRst {
/* 800157F4 */ u32 getResetData();
static u8 mResetData[4 + 4 /* padding */];
};
struct Z2AudioMgr {
/* 802CDA6C */ void hasReset() const;
@@ -55,7 +50,7 @@ extern "C" void mDoRst_resetCallBack__FiPv();
extern "C" u32 getResetData__6mDoRstFv();
extern "C" extern char const* const m_Do_m_Do_Reset__stringBase0;
extern "C" u8 mResetData__6mDoRst[4 + 4 /* padding */];
extern "C" extern u8 struct_80450C80[8];
extern "C" extern u64 struct_80450C80;
extern "C" extern u8 data_80450C88[8];
//
@@ -83,13 +78,10 @@ extern "C" void DVDGetDriveStatus();
extern "C" void DVDCheckDisk();
extern "C" void VIWaitForRetrace();
extern "C" void VIFlush();
extern "C" void VISetBlack();
extern "C" void GXSetCurrentGXThread();
extern "C" void GXGetCurrentGXThread();
extern "C" void VISetBlack(s32);
extern "C" void GXFlush();
extern "C" void GXAbortFrame();
extern "C" void GXDrawDone();
extern "C" void GXSetDrawDoneCallback();
extern "C" void _savegpr_27();
extern "C" extern u8 g_mDoMemCd_control[8192];
extern "C" extern u8 struct_80450BB8[4];
@@ -103,20 +95,18 @@ extern "C" u8 sManager__6JUTXfb[4 + 4 /* padding */];
// Declarations:
//
/* 800155D8-800155DC 00FF18 0004+00 1/1 0/0 0/0 .text my_OSCancelAlarmAll__Fv */
static void my_OSCancelAlarmAll() {
/* empty function */
}
/* 800155DC-80015614 00FF1C 0038+00 1/1 0/0 0/0 .text destroyVideo__Fv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void destroyVideo() {
nofralloc
#include "asm/m_Do/m_Do_Reset/destroyVideo__Fv.s"
static void destroyVideo() {
destroyManager__8JUTVideoFv();
GXSetDrawDoneCallback(NULL);
VISetBlack(1);
VIFlush();
VIWaitForRetrace();
return;
}
#pragma pop
/* ############################################################################################## */
/* 80374198-80374198 0007F8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@@ -126,9 +116,70 @@ SECTION_DEAD static char const* const stringBase_80374198 = "DVD_STATE_BUSY\n";
#pragma pop
/* 80450C78-80450C80 000178 0004+04 3/2 42/42 2/2 .sbss mResetData__6mDoRst */
u8 mDoRst::mResetData[4 + 4 /* padding */];
mDoRstData* mDoRst::mResetData;
/* 80015614-8001574C 00FF54 0138+00 0/0 3/3 0/0 .text mDoRst_reset__FiUli */
#ifdef NONMATCHING
void mDoRst_reset(int p1, u32 p2, int p3) {
mDoCPd_c* pmVar1;
u32 uVar2;
DVDState DVar3;
OSThread* thread;
s32 enable;
/* sManager */ lbl_80451550->clearIndex();
mDoDvdErr_ThdCleanup__Fv();
cAPICPad_recalibrate__Fv();
if (lbl_80450BB8 != false) {
do {
uVar2 = lbl_80451368->hasReset();
} while ((uVar2 & 0xff) == 0);
}
if ((s32)DVDGetDriveStatus() == (s32)DVD_STATE_BUSY) {
OSAttention(lbl_80374198);
}
JASTaskThread* task_thread = getThreadPointer__6JASDvdFv();
if (task_thread != NULL) {
pause__13JASTaskThreadFb(task_thread, true);
thread = task_thread->thread;
if (thread != NULL) {
OSSuspendThread(thread);
OSDetachThread(thread);
OSCancelThread(thread);
}
}
VIWaitForRetrace();
VIWaitForRetrace();
thread = GXGetCurrentGXThread();
enable = OSDisableInterrupts();
OSThread* ourThread = OSGetCurrentThread();
if (thread != ourThread) {
OSCancelThread(thread);
GXSetCurrentGXThread();
}
GXFlush();
GXAbortFrame();
GXDrawDone();
OSRestoreInterrupts(enable);
destroyVideo();
while (mDoMemCd_isCardCommNone() != 0) {
VIWaitForRetrace();
}
my_OSCancelAlarmAll();
LCDisable();
// probably false match; check out 80015728 or thereabouts in Ghidra
OSSetSaveRegion(mDoRst::mResetData, (u8*)(&mDoRst::getResetData()) + 0x18);
OSResetSystem(p1, p2, p3);
do {
VIWaitForRetrace();
} while (true);
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -137,8 +188,34 @@ asm void mDoRst_reset(int param_0, u32 param_1, int param_2) {
#include "asm/m_Do/m_Do_Reset/mDoRst_reset__FiUli.s"
}
#pragma pop
#endif
/* 8001574C-800157F4 01008C 00A8+00 0/0 3/3 0/0 .text mDoRst_resetCallBack__FiPv */
// fix JUTGamePad data
#ifdef NONMATCHING
void mDoRst_resetCallBack(int port, void* p2) {
if (!mDoRst::isReset()) {
if (port == -1) {
cAPICPad_recalibrate__Fv();
} else {
if (mDoRst::is3ButtonReset() != 0) {
lbl_80451501 = false;
/* sCallback */ lbl_804514EC = &mDoRst_resetCallBack;
/* sCallbackArg */ lbl_804514F0 = 0;
return;
}
mDoRst::on3ButtonReset();
mDoRst::set3ButtonResetPort(port);
cAPICPad_recalibrate__Fv();
}
if ((DVDCheckDisk() == 0) && (DVDGetDriveStatus() != DVD_STATE_FATAL_ERROR)) {
mDoRst::onReturnToMenu();
}
mDoRst::onReset();
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -147,18 +224,20 @@ asm void mDoRst_resetCallBack(int param_0, void* param_1) {
#include "asm/m_Do/m_Do_Reset/mDoRst_resetCallBack__FiPv.s"
}
#pragma pop
#endif
/* 800157F4-800157FC -00001 0008+00 0/0 0/0 0/0 .text getResetData__6mDoRstFv */
u32 mDoRst::getResetData() {
return *(u32*)(&mDoRst::mResetData);
mDoRstData* mDoRst::getResetData() {
return mResetData;
}
/* ############################################################################################## */
/* 80450C80-80450C88 -00001 0008+00 0/0 6/6 0/0 .sbss None */
/* 80450C80 0001+00 data_80450C80 None */
/* 80450C81 0007+00 data_80450C81 None */
extern u8 struct_80450C80[8];
u8 struct_80450C80[8];
// type might be fake, used for now to align to 8
extern u64 struct_80450C80;
u64 struct_80450C80;
/* 80450C88-80450C90 000188 0008+00 0/0 2/2 0/0 .sbss None */
extern u8 data_80450C88[8];
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
src/m_Do/m_Do_main.cpp
+488 -155
View File
@@ -4,8 +4,11 @@
//
#include "m_Do/m_Do_main.h"
#include "JSystem/JUtility/JUTReport.h"
#include "dol2asm.h"
#include "dolphin/types.h"
#include "m_Do/m_Do_controller_pad.h"
#include "msl_c/string.h"
//
// Types:
@@ -19,25 +22,10 @@ struct mDoMemCd_Ctrl_c {
/* 80016894 */ void update();
};
struct mDoMain {
static u8 COPYDATE_STRING[18 + 2 /* padding */];
static u32 memMargin;
static u8 sPowerOnTime[4];
static u8 sHungUpTime[4];
};
struct mDoDvdThd_callback_c {
/* 80015C74 */ void create(void* (*)(void*), void*);
};
struct mDoCPd_c {
/* 80007954 */ void create();
/* 80007A94 */ void read();
static u8 m_gamePad[16];
static u8 m_cpadInfo[256];
};
struct dRes_control_c {
/* 8003C638 */ void dump();
};
@@ -57,24 +45,10 @@ struct JUTAssertion {
/* 802E4C3C */ void setMessageCount(int);
};
struct JKRHeap {
/* 800065D8 */ bool dump_sort();
/* 802CE72C */ void getFreeSize();
/* 802CE784 */ void getTotalFreeSize();
static u8 sSystemHeap[4];
static u8 sCurrentHeap[4];
static u8 sRootHeap[4];
};
struct JKRSolidHeap {
/* 802D0A24 */ void create(u32, JKRHeap*, bool);
};
struct JKRExpHeap {
/* 802CFD64 */ void getTotalUsedSize() const;
};
struct JKRAramHeap {
/* 802D3134 */ void getFreeSize();
/* 802D31AC */ void getTotalFreeSize();
@@ -89,12 +63,6 @@ struct JFWSystem {
static u8 systemConsole[4];
};
struct HeapCheck {
/* 80005728 */ void CheckHeap1();
/* 800058A0 */ void getUsedCount() const;
/* 800058C4 */ void heapDisplay() const;
};
struct DynamicModuleControlBase {
/* 80262470 */ void dump();
};
@@ -152,9 +120,7 @@ extern "C" extern u8 data_80450B9C[4];
// External References:
//
SECTION_INIT void memcpy();
extern "C" void OSReportInit__Fv();
extern "C" void OSReport_Error();
extern "C" void mDoAud_Execute__Fv();
extern "C" void create__8mDoCPd_cFv();
extern "C" void read__8mDoCPd_cFv();
@@ -190,23 +156,6 @@ extern "C" void clear__10JUTConsoleFv();
extern "C" void dumpToTerminal__10JUTConsoleFUi();
extern "C" void scroll__10JUTConsoleFi();
extern "C" void getLineOffset__10JUTConsoleCFv();
extern "C" void OSGetConsoleType();
extern "C" void OSAllocFromArenaLo();
extern "C" void OSGetResetCode();
extern "C" void OSGetCurrentThread();
extern "C" void OSDisableScheduler();
extern "C" void OSEnableScheduler();
extern "C" void OSCreateThread();
extern "C" void OSResumeThread();
extern "C" void OSSuspendThread();
extern "C" void OSSetThreadPriority();
extern "C" void OSGetThreadPriority();
extern "C" void OSCheckActiveThreads();
extern "C" void OSGetTime();
extern "C" void DVDOpen();
extern "C" void DVDClose();
extern "C" void DVDReadPrio();
extern "C" void DVDGetCurrentDiskID();
extern "C" void _savegpr_23();
extern "C" void _savegpr_26();
extern "C" void _savegpr_27();
@@ -215,7 +164,6 @@ extern "C" void _restgpr_23();
extern "C" void _restgpr_26();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void strcmp();
extern "C" u8 m_gamePad__8mDoCPd_c[16];
extern "C" u8 m_cpadInfo__8mDoCPd_c[256];
extern "C" extern u8 g_mDoMemCd_control[8192];
@@ -237,62 +185,57 @@ extern "C" u8 sAramObject__7JKRAram[4];
// Declarations:
//
/* ############################################################################################## */
/* 803739A0-803739A0 000000 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_803739A0 = "20Apr2004";
SECTION_DEAD static char const* const stringBase_803739AA = "Patch2";
SECTION_DEAD static char const* const stringBase_803739B1 =
"SDKのバージョンが一致しません。停止します\n";
#pragma pop
static void version_check() {
if ((!strcmp("20Apr2004", "20Apr2004")) && (!strcmp("Patch2", "Patch2"))) {
return;
}
/* 800056C0-80005728 000000 0068+00 1/1 0/0 0/0 .text version_check__Fv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void version_check() {
nofralloc
#include "asm/m_Do/m_Do_main/version_check__Fv.s"
// "SDK version doesn't match. Stopping\n"
OSReport_Error("SDKのバージョンが一致しません。停止します\n");
do {
} while (true);
}
#pragma pop
/* 80005728-8000578C 000068 0064+00 1/1 0/0 0/0 .text CheckHeap1__9HeapCheckFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void HeapCheck::CheckHeap1() {
nofralloc
#include "asm/m_Do/m_Do_main/CheckHeap1__9HeapCheckFv.s"
void HeapCheck::CheckHeap1() {
s32 totalUsedSize = mHeap->getTotalUsedSize();
s32 freeSize = mHeap->getFreeSize();
if (mMaxTotalUsedSize < totalUsedSize) {
mMaxTotalUsedSize = totalUsedSize;
}
if (mMaxTotalFreeSize > freeSize) {
mMaxTotalFreeSize = freeSize;
}
}
#pragma pop
/* ############################################################################################## */
/* 803D32E0-803D3308 000000 0028+00 3/2 0/0 0/0 .bss RootHeapCheck */
extern "C" u8 RootHeapCheck[40];
extern "C" HeapCheck RootHeapCheck;
/* 803D3308-803D3330 000028 0028+00 1/2 0/0 0/0 .bss SystemHeapCheck */
extern "C" u8 SystemHeapCheck[40];
extern "C" HeapCheck SystemHeapCheck;
/* 803D3330-803D3358 000050 0028+00 1/2 0/0 0/0 .bss ZeldaHeapCheck */
extern "C" u8 ZeldaHeapCheck[40];
extern "C" HeapCheck ZeldaHeapCheck;
/* 803D3358-803D3380 000078 0028+00 1/2 0/0 0/0 .bss GameHeapCheck */
extern "C" u8 GameHeapCheck[40];
extern "C" HeapCheck GameHeapCheck;
/* 803D3380-803D33A8 0000A0 0028+00 1/2 0/0 0/0 .bss ArchiveHeapCheck */
extern "C" u8 ArchiveHeapCheck[40];
extern "C" HeapCheck ArchiveHeapCheck;
/* 803D33A8-803D33D0 0000C8 0028+00 1/2 0/0 0/0 .bss J2dHeapCheck */
extern "C" u8 J2dHeapCheck[40];
extern "C" HeapCheck J2dHeapCheck;
/* 803D33D0-803D33F8 0000F0 0028+00 1/2 0/0 0/0 .bss HostioHeapCheck */
extern "C" u8 HostioHeapCheck[40];
extern "C" HeapCheck HostioHeapCheck;
/* 803D33F8-803D3420 000118 0028+00 1/2 0/0 0/0 .bss CommandHeapCheck */
extern "C" u8 CommandHeapCheck[40];
extern "C" HeapCheck CommandHeapCheck;
/* 803A2EE0-803A2EF4 000000 0012+02 2/2 1/1 0/0 .data COPYDATE_STRING__7mDoMain */
// "??/??/?? ??:??:?"
SECTION_DATA u8 mDoMain::COPYDATE_STRING[18 + 2 /* padding */] = {
0x3F,
0x3F,
@@ -318,37 +261,62 @@ SECTION_DATA u8 mDoMain::COPYDATE_STRING[18 + 2 /* padding */] = {
};
/* 803A2EF4-803A2F14 -00001 0020+00 1/2 0/0 0/0 .data HeapCheckTable */
SECTION_DATA static void* HeapCheckTable[8] = {
(void*)&RootHeapCheck, (void*)&SystemHeapCheck, (void*)&ZeldaHeapCheck,
(void*)&GameHeapCheck, (void*)&ArchiveHeapCheck, (void*)&J2dHeapCheck,
(void*)&HostioHeapCheck, (void*)&CommandHeapCheck,
SECTION_DATA static HeapCheck* HeapCheckTable[8] = {
&RootHeapCheck, &SystemHeapCheck, &ZeldaHeapCheck, &GameHeapCheck,
&ArchiveHeapCheck, &J2dHeapCheck, &HostioHeapCheck, &CommandHeapCheck,
};
/* 803D32E0-803D3308 000000 0028+00 3/2 0/0 0/0 .bss RootHeapCheck */
static u8 RootHeapCheck[40];
static HeapCheck RootHeapCheck;
/* 803D3308-803D3330 000028 0028+00 1/2 0/0 0/0 .bss SystemHeapCheck */
static u8 SystemHeapCheck[40];
static HeapCheck SystemHeapCheck;
/* 803D3330-803D3358 000050 0028+00 1/2 0/0 0/0 .bss ZeldaHeapCheck */
static u8 ZeldaHeapCheck[40];
static HeapCheck ZeldaHeapCheck;
/* 803D3358-803D3380 000078 0028+00 1/2 0/0 0/0 .bss GameHeapCheck */
static u8 GameHeapCheck[40];
static HeapCheck GameHeapCheck;
/* 803D3380-803D33A8 0000A0 0028+00 1/2 0/0 0/0 .bss ArchiveHeapCheck */
static u8 ArchiveHeapCheck[40];
static HeapCheck ArchiveHeapCheck;
/* 803D33A8-803D33D0 0000C8 0028+00 1/2 0/0 0/0 .bss J2dHeapCheck */
static u8 J2dHeapCheck[40];
static HeapCheck J2dHeapCheck;
/* 803D33D0-803D33F8 0000F0 0028+00 1/2 0/0 0/0 .bss HostioHeapCheck */
static u8 HostioHeapCheck[40];
static HeapCheck HostioHeapCheck;
/* 803D33F8-803D3420 000118 0028+00 1/2 0/0 0/0 .bss CommandHeapCheck */
static u8 CommandHeapCheck[40];
static HeapCheck CommandHeapCheck;
/* 8000578C-80005848 0000CC 00BC+00 1/1 0/0 0/0 .text CheckHeap__FUl */
#ifdef NONMATCHING
void CheckHeap(u32 controller_pad_no) {
mDoMch_HeapCheckAll__Fv();
OSCheckActiveThreads();
bool unk = false;
// if L + R + Z is pressed...
if (((m_cpadInfo[controller_pad_no].mButtonFlags & ~0x10) == 0x60) &&
m_cpadInfo[controller_pad_no].mPressedButtonFlags & 0x10) {
unk = true;
}
for (int i = 0; i < 8; i++) {
HeapCheckTable[i]->CheckHeap1();
if (unk) {
HeapCheck* currentHeap = HeapCheckTable[i];
s32 used_count = currentHeap->getUsedCount();
currentHeap->getUsedCountRef() = used_count;
used_count = currentHeap->getHeap()->getTotalUsedSize();
currentHeap->getTotalUsedSizeRef() = used_count;
}
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -357,54 +325,51 @@ static asm void CheckHeap(u32 param_0) {
#include "asm/m_Do/m_Do_main/CheckHeap__FUl.s"
}
#pragma pop
#endif
/* 80005848-800058A0 000188 0058+00 2/2 0/0 0/0 .text countUsed__FP10JKRExpHeap */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void countUsed(JKRExpHeap* param_0) {
nofralloc
#include "asm/m_Do/m_Do_main/countUsed__FP10JKRExpHeap.s"
static int countUsed(JKRExpHeap* heap) {
OSDisableScheduler();
int counter = 0;
JKRExpHeap::CMemBlock* used_blocks_head = heap->getHeadUsedList();
while (used_blocks_head) {
used_blocks_head = used_blocks_head->getNextBlock();
counter++;
};
OSEnableScheduler();
return counter;
}
#pragma pop
/* 800058A0-800058C4 0001E0 0024+00 2/2 0/0 0/0 .text getUsedCount__9HeapCheckCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void HeapCheck::getUsedCount() const {
nofralloc
#include "asm/m_Do/m_Do_main/getUsedCount__9HeapCheckCFv.s"
s32 HeapCheck::getUsedCount() const {
return countUsed(mHeap);
}
#pragma pop
/* ############################################################################################## */
/* 803739A0-803739A0 000000 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_803739DC = "[%sName]";
SECTION_DEAD static char const* const stringBase_803739E5 = "HeapSize %8ld";
SECTION_DEAD static char const* const stringBase_803739FB = "TargetHeapSize %8ld";
SECTION_DEAD static char const* const stringBase_80373A11 = "TotalFree %8ld";
SECTION_DEAD static char const* const stringBase_80373A27 = "FreeSize %8ld";
SECTION_DEAD static char const* const stringBase_80373A3D = "TotalUsedSize %8ld";
SECTION_DEAD static char const* const stringBase_80373A53 = "TotalUsedRate %3ld%%";
SECTION_DEAD static char const* const stringBase_80373A6F = "MaxTotalUsedSize %8ld";
SECTION_DEAD static char const* const stringBase_80373A85 = "MaxTotalUsedRate %3ld%%";
SECTION_DEAD static char const* const stringBase_80373AA1 = "MinFreeSize %8ld";
SECTION_DEAD static char const* const stringBase_80373AB7 = "MinFreeRate %3ld%%";
SECTION_DEAD static char const* const stringBase_80373AD3 = "UsedCount %3ld%";
#pragma pop
void HeapCheck::heapDisplay() const {
s32 heap_size = mHeap->getSize();
s32 used_count = heap_size - mTargetHeapSize;
/* 800058C4-80005AD8 000204 0214+00 1/1 0/0 0/0 .text heapDisplay__9HeapCheckCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void HeapCheck::heapDisplay() const {
nofralloc
#include "asm/m_Do/m_Do_main/heapDisplay__9HeapCheckCFv.s"
s32 total_used_size = mHeap->getTotalUsedSize();
s32 total_free_size = mHeap->getTotalFreeSize();
s32 heap_free_size = mHeap->getFreeSize();
JUTReport(0x64, 0xd4, "[%sName]", mName);
JUTReport(0x64, 0xe3, "HeapSize %8ld", heap_size);
JUTReport(0x64, 0xf0, "TargetHeapSize %8ld", mTargetHeapSize);
JUTReport(0x64, 0xfd, "TotalFree %8ld", total_free_size - used_count);
JUTReport(0x64, 0x10a, "FreeSize %8ld", heap_free_size - used_count);
JUTReport(0x64, 0x117, "TotalUsedSize %8ld", total_used_size);
JUTReport(0x64, 0x124, "TotalUsedRate %3ld%%",
(int)(total_used_size * 0x64) / (int)mTargetHeapSize);
JUTReport(0x64, 0x131, "MaxTotalUsedSize %8ld", mMaxTotalUsedSize);
JUTReport(0x64, 0x13e, "MaxTotalUsedRate %3ld%%",
(mMaxTotalUsedSize * 0x64) / (int)mTargetHeapSize);
JUTReport(0x64, 0x14b, "MinFreeSize %8ld", mMaxTotalFreeSize - used_count);
JUTReport(0x64, 0x158, "MinFreeRate %3ld%%",
((mMaxTotalFreeSize - used_count) * 0x64) / (int)mTargetHeapSize);
used_count = countUsed(mHeap);
JUTReport(0x64, 0x165, "UsedCount %3ld%", used_count);
}
#pragma pop
/* ############################################################################################## */
/* 803739A0-803739A0 000000 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@@ -452,7 +417,7 @@ SECTION_DATA static void* desc2[5 + 1 /* padding */] = {
#pragma pop
/* 80450580-80450584 000000 0004+00 3/3 6/6 0/0 .sdata None */
SECTION_SDATA extern u32 data_80450580 = 0xFF000000;
SECTION_SDATA extern s8 data_80450580 = 0xFF;
/* 80450584-80450588 000004 0004+00 0/0 1/1 0/0 .sdata memMargin__7mDoMain */
SECTION_SDATA u32 mDoMain::memMargin = 0xFFFFFFFF;
@@ -466,16 +431,14 @@ SECTION_SDATA static u8 data_80450588[8] = {
static u8 data_80450B00[8];
/* 80450B08-80450B0C 000008 0004+00 1/1 1/1 0/0 .sbss sPowerOnTime__7mDoMain */
// should be OSTime
u8 mDoMain::sPowerOnTime[4];
/* 80450B0C-80450B10 00000C 0004+00 1/1 1/1 0/0 .sbss None */
extern u8 data_80450B0C[4];
u8 data_80450B0C[4];
/* 80450B10-80450B14 000010 0004+00 0/0 2/2 0/0 .sbss sHungUpTime__7mDoMain */
// should be OSTime
u8 mDoMain::sHungUpTime[4];
/* 80450B14-80450B18 000014 0004+00 0/0 2/2 0/0 .sbss None */
extern u8 data_80450B14[4];
u8 data_80450B14[4];
@@ -483,9 +446,74 @@ u8 data_80450B14[4];
/* 80450B18 0001+00 data_80450B18 None */
/* 80450B19 0001+00 data_80450B19 None */
/* 80450B1A 0002+00 data_80450B1A None */
static u8 struct_80450B18[4];
static u8 struct_80450B18[2];
static u8 data_80450B1A;
static u8 data_80450B1B;
/* 80005AD8-80005D4C 000418 0274+00 1/1 0/0 0/0 .text debugDisplay__Fv */
#ifdef NONMATCHING
void debugDisplay(void) {
int tmp1;
int tmp2;
HeapCheck** hct = (HeapCheck**)lbl_803A2EE0;
if (lbl_80450B19 >= 1 && lbl_80450B19 <= 6) {
hct[lbl_80450B19 - 1]->heapDisplay();
}
if (lbl_80450588 == 5) {
JKRAramHeap* heap = sAramObject__7JKRAram->getAramHeap();
if (heap) {
JUTReport(0x1db, 100, lbl_803739A0 + 0x196);
JUTReport(0x1db, 0x72, lbl_803739A0 + 0x1A0, heap->getFreeSize());
JUTReport(0x1db, 0x80, lbl_803739A0 + 0x150);
JUTReport(0x1db, 0x8e, lbl_803739A0 + 0x1A0, heap->getTotalFreeSize());
}
} else {
if (lbl_80450588) {
JUTReport(0x1db, 100, lbl_803739A0 + 0x1A3, lbl_803A2F14[lbl_80450588]);
JUTReport(0x1db, 0x72, lbl_803739A0 + 0x1A3, lbl_803A2F28[lbl_80450588]);
int k = 0;
for (int i = 0; i < 8; i++, k += 0x2c) {
// heap check table stuff
HeapCheck* heap_check;
heap_check = HeapCheckTable[i];
switch (lbl_80450588) {
case 3: {
tmp1 = heap_check->getUsedCount();
tmp2 = heap_check->getHeap()->getTotalUsedSize();
break;
}
case 1: {
tmp1 = heap_check->getHeap()->getTotalFreeSize();
tmp2 = heap_check->getHeap()->getFreeSize();
break;
}
case 2: {
tmp1 = heap_check->getMaxTotalUsedSize();
tmp2 = heap_check->getHeap()->getSize();
break;
}
case 4: {
tmp1 = heap_check->getUsedCount() - heap_check->getUsedCountRef();
tmp2 = heap_check->getHeap()->getTotalUsedSize() -
heap_check->getTotalUsedSizeRef();
break;
}
JUTReport(0x1db, k + 0x96, lbl_80373B46, heap_check->getNames()[0]);
JUTReport(0x1db, k + 0xA4, lbl_80373B4C, tmp1);
JUTReport(0x1db, k + 0xB2, lbl_80373B4C, tmp2);
}
}
}
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -494,6 +522,7 @@ static asm void debugDisplay() {
#include "asm/m_Do/m_Do_main/debugDisplay__Fv.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 803739A0-803739A0 000000 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@@ -555,6 +584,121 @@ SECTION_SDATA2 static f32 lit_3888[1 + 1 /* padding */] = {
SECTION_SDATA2 static f64 lit_3890 = 4503601774854144.0 /* cast s32 to float */;
/* 80005D4C-8000614C 00068C 0400+00 1/1 0/0 0/0 .text Debug_console__FUl */
#ifdef NONMATCHING
void Debug_console(u32 controller_pad_no) {
float tmp2;
float tmp3;
int tmp6;
// systemConsole
if (lbl_804511B8) {
if (!lbl_80450B20) {
lbl_80450B1C = lbl_80451A00;
lbl_80450B20 = 1;
}
if (!lbl_80450B28) {
lbl_80450B24 = lbl_80451A04;
lbl_80450B28 = 1;
}
if (!lbl_80450B30) {
lbl_80450B2C = lbl_80451A08;
lbl_80450B30 = 1;
}
u32 tmp5 = m_cpadInfo[controller_pad_no].mPressedButtonFlags;
if ((m_cpadInfo[controller_pad_no].mPressedButtonFlags & 0x10) &&
!(m_cpadInfo[controller_pad_no].mButtonFlags & ~0x10)) {
lbl_804511B8->field_0x68 = !lbl_804511B8->field_0x68;
JUTAssertion::setMessageCount(0);
}
if (lbl_804511B8->field_0x68) {
u32 tmp = m_cpadInfo[controller_pad_no].mButtonFlags;
// if R and L are pressed
if ((tmp & CButton::R && tmp & CButton::L) ||
((lbl_80451A08 > m_cpadInfo[controller_pad_no].mTriggerLeft) &&
(lbl_80451A08 > m_cpadInfo[controller_pad_no].mTriggerRight))) {
tmp2 = m_cpadInfo[controller_pad_no].mMainStickPosX;
tmp3 = m_cpadInfo[controller_pad_no].mMainStickPosY;
// if x buttons are pressed, clear the console
if (tmp & (CButton::Y | CButton::START) && tmp5 & CButton::START) {
lbl_804511B8->clear();
}
u32 tmp = m_cpadInfo[controller_pad_no].mButtonFlags;
if (!(tmp & (CButton::Y | CButton::START))) {
// subtract console scroll value from stick Y
float tmp4 = lbl_80450B2C;
lbl_80450B2C = tmp4 - tmp3;
if (lbl_80450B2C <= lbl_80451A0C) {
lbl_80451A10 <= lbl_80450B2C ? tmp = 0 : tmp = lbl_80451A0C;
} else {
tmp = (tmp4 - tmp3);
}
if (tmp) {
lbl_80450B2C -= (tmp ^ 0x80000000) - 4503601774854144.00000000;
lbl_804511B8->scroll(tmp);
}
} else {
if (tmp & CButton::X) {
lbl_80450B2C += tmp2;
}
if (tmp & CButton::Y) {
lbl_80450B2C -= tmp3;
}
}
if (tmp5 & CButton::A) {
lbl_804511B8->dumpToTerminal(0xFFFFFFFF);
lbl_804511B8->field_0x58 = 3;
}
JUTReport(0x1E, 0x186, 1, lbl_80373B51);
JUTReport(0x1E, 400, 1, lbl_80373B73);
JUTReport(0x1E, 0x19A, 1, lbl_80373B8D);
tmp6 = lbl_804511B8->getLineOffset();
JUTReport(0x1E, 0x1A4, 1, lbl_80373BB6, tmp6, lbl_804511B8->field_0x40,
lbl_804511B8->field_0x44, lbl_804511B8->field_0x58);
}
} else {
if (tmp5 & 4) {
g_HIO.field_0x15 ^= 1;
}
if (tmp5 & 1) {
if (sAramObject__7JKRAram->getAramHeap()) {
sAramObject__7JKRAram->getAramHeap()->dump();
}
dump__24DynamicModuleControlBaseFv();
dump__14dRes_control_cFv();
}
if (tmp5 & 2) {
sSystemHeap__7JKRHeap->dump_sort();
}
if (tmp5 & 8) {
lbl_80450C2C->dump_sort();
lbl_80450C28->dump_sort();
lbl_80450C34->dump_sort();
}
JUTReport(0x1E, 0x1B8, 1, lbl_80373BD5);
JUTReport(0x1E, 0x1C2, 1, lbl_80373BFB);
}
lbl_804511B8->field_0x40 = lbl_80450B1C;
lbl_804511B8->field_0x44 = lbl_80450B24;
tmp6 = 1;
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -563,6 +707,7 @@ static asm void Debug_console(u32 param_0) {
#include "asm/m_Do/m_Do_main/Debug_console__FUl.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 803739A0-803739A0 000000 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@@ -572,6 +717,23 @@ SECTION_DEAD static char const* const stringBase_80373C23 = "/str/Final/Release/
#pragma pop
/* 8000614C-800061C8 000A8C 007C+00 1/1 0/0 0/0 .text LOAD_COPYDATE__FPv */
#ifdef NONMATCHING
s32 LOAD_COPYDATE(void*) {
s32 status;
u8 buffer[32];
u8 fileInfo[80];
// DVDFileInfo fileInfo;
status = DVDOpen("/str/Final/Release/COPYDATE", (DVDFileInfo*)&fileInfo);
if (status) {
DVDReadPrio((DVDFileInfo*)fileInfo, &buffer, 32, 0, 2);
memcpy(lbl_803A2EE0, buffer, 17);
status = DVDClose((DVDFileInfo*)fileInfo);
}
return status;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -580,22 +742,138 @@ static asm void LOAD_COPYDATE(void* param_0) {
#include "asm/m_Do/m_Do_main/LOAD_COPYDATE__FPv.s"
}
#pragma pop
#endif
/* 800061C8-8000628C 000B08 00C4+00 1/1 0/0 0/0 .text debug__Fv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void debug() {
nofralloc
#include "asm/m_Do/m_Do_main/debug__Fv.s"
static void debug() {
if (data_80450580) {
if (data_80450B1A) {
CheckHeap(2);
}
if (((mDoCPd_c::m_gamePad[2]->buttons.mButtonFlags & ~0x10) == 0x20) &&
(mDoCPd_c::m_gamePad[2]->buttons.mPressedButtonFlags & 0x10)) {
struct_80450B18[0] ^= 0x1;
}
if (struct_80450B18[0]) {
if (((mDoCPd_c::m_gamePad[2]->buttons.mButtonFlags & ~0x10) == 0x40) &&
(mDoCPd_c::m_gamePad[2]->buttons.mPressedButtonFlags & 0x10)) {
data_80450588[0] < 0x5 ? data_80450588[0]++ : data_80450588[0] = 0x1;
}
debugDisplay();
}
Debug_console(2);
}
}
#pragma pop
/* ############################################################################################## */
/* 80450B34-80450B38 000034 0004+00 1/1 0/0 0/0 .sbss frame$3939 */
static u8 frame[4];
/* 8000628C-80006454 000BCC 01C8+00 1/1 0/0 0/0 .text main01__Fv */
#ifdef NONMATCHING
void main01(void) {
HeapCheck* heaps = lbl_803D32E0;
mDoMch_Create__Fv();
mDoGph_Create();
create__8mDoCPd_cFv();
// mDoDVDThd_callback_c thread_callback;
// JKRSolidHeap audio_heap;
// Root Heap
heaps[0].setHeap((JKRExpHeap*)JKRHeap::getRootHeap());
if (JKRHeap::getRootHeap()) {
heaps[0].setHeapSize(JKRHeap::getRootHeap()->getSize());
}
// System Heap
heaps[1].setHeap((JKRExpHeap*)JKRHeap::getSystemHeap());
if (JKRHeap::getSystemHeap()) {
heaps[1].setHeapSize(JKRHeap::getSystemHeap()->getSize());
}
// Zelda Heap
heaps[2].setHeap(mDoExt_getZeldaHeap());
if (heaps[2].getHeap()) {
heaps[2].setHeapSize(heaps[2].getHeap()->getSize());
}
// Game Heap
heaps[3].setHeap(mDoExt_getGameHeap());
if (heaps[3].getHeap()) {
heaps[3].setHeapSize(heaps[3].getHeap()->getSize());
}
// Archive Heap
heaps[4].setHeap(mDoExt_getArchiveHeap());
if (heaps[4].getHeap()) {
heaps[4].setHeapSize(heaps[4].getHeap()->getSize());
}
// J2D Heap
heaps[5].setHeap(mDoExt_getJ2dHeap());
if (heaps[5].getHeap()) {
heaps[5].setHeapSize(heaps[5].getHeap()->getSize());
}
// HostIO Heap
heaps[6].setHeap(mDoExt_getHostIOHeap());
if (heaps[6].getHeap()) {
heaps[6].setHeapSize(heaps[6].getHeap()->getSize());
}
// Command Heap
heaps[7].setHeap(mDoExt_getCommandHeap());
JUTConsole* systemConsole = lbl_804511B8;
if (heaps[7].getHeap()) {
heaps[7].setHeapSize(heaps[7].getHeap()->getSize());
}
u32 unk = 0;
if (lbl_80450580) {
unk = 3;
}
systemConsole->field_0x58 = unk;
systemConsole->field_0x40 = 0x20;
systemConsole->field_0x44 = 0x2A;
// lol
mDoDVDThd_callback_c::create(LOAD_COPYDATE, 0);
fapGm_Create();
fopAcM_initManager();
lbl_80450B18 = 0;
cDyl_InitAsync__Fv();
// g_mDoAud_audioHeap
lbl_80450BBC = JKRSolidHeap::create(0x14d800, JKRHeap::getCurrentHeap(), false);
// main loop
do {
// global frame counter?
lbl_80450B34++;
if (lbl_80450B00 && (lbl_80450B34 == ((lbl_80450B34 / lbl_80450B00) * lbl_80450B00))) {
mDoMch_HeapCheckAll__Fv();
}
if (lbl_80450C80) {
update__15mDoMemCd_Ctrl_cFv();
}
mDoCPd_c_NS_read();
fapGm_Execute();
mDoAud_Execute();
debug();
} while (true);
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -604,6 +882,7 @@ static asm void main01() {
#include "asm/m_Do/m_Do_main/main01__Fv.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 803D3420-803DB420 000140 8000+00 1/1 0/0 0/0 .bss mainThreadStack */
@@ -613,6 +892,59 @@ static u8 mainThreadStack[32768];
static u8 mainThread[792 + 8 /* padding */];
/* 80006454-800065D8 000D94 0184+00 0/0 1/1 0/0 .text main */
#ifdef NONMATCHING
void main() {
u32 resetCode;
OSThread* current_thread = OSGetCurrentThread();
OSPriority* priority;
mDoMain::sPowerOnTime = OSGetTime();
OSReportInit();
version_check();
mDoRstData* reset_data = (mDoRstData*)OSAllocFromArenaLo(0x18, 4);
mDoRst::setResetData(reset_data);
if (!mDoRst::getResetData()) {
do {
} while (true);
}
if (!(OSGetResetCode() & 0x80000000)) {
mDoRst::offReset();
mDoRst::offResetPrepare();
mDoRst::off3ButtonReset();
mDoRst::off3ButtonResetPort(-1);
mDoRst::setLogoScnFlag(0);
mDoRst::setProgSeqFlag(0);
mDoRst::setProgChgFlag(0);
mDoRst::setWarningDispFlag(0);
mDoRst::offShutdown();
mDoRst::offReturnToMenu();
}
dComIfG_ct();
if (data_80450580 < 0) {
DVDDiskID* disk_id = DVDGetCurrentDiskID();
if (disk_id->game_version <= 0x90) {
if (disk_id->game_version <= 0x80) {
data_80450580 = 0;
} else {
resetCode = OSGetConsoleType();
data_80450580 = (-(resetCode & 0x10000000) >> 0x1f);
}
} else {
data_80450580 = 1;
}
}
priority = OSGetThreadPriority(current_thread);
OSCreateThread(&mainThread, main01, 0, &mainThread, 0x8000, priority, 0);
OSResumeThread(&mainThread);
OSSetThreadPriority(current_thread, 0x1F);
OSSuspendThread(current_thread);
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -621,6 +953,7 @@ asm void main() {
#include "asm/m_Do/m_Do_main/main.s"
}
#pragma pop
#endif
/* 800065D8-800065E0 000F18 0008+00 0/0 2/0 0/0 .text dump_sort__7JKRHeapFv */
bool JKRHeap::dump_sort() {