mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-08-10 18:46:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

A few f_pc files (#26)

Browse Source 
* f_pc_base, one non matching

* some of f_pc_manager

* f_pc_node OK

* f_pc_pause partly

* started node_req

* more progress

* most of node req

* delete unused asm

* node req header and param names

* param renaming

* header for manager

* review comment struct names

* fpcM_Management OK

* int -> s32

* merge master

* most of f_pc_create_iter

* f_pc_stdcreate_req OK

* f_pc_fstcreate OK

* f_pc_leaf OK

* f_pc_draw OK

* f_pc_deletor partly

* fix parameter type in f_pc_pause

* review

* review, use cPh enum and fix process_profile_definition struct

* convert f_pc files to C

* matched more functions

* fix global.h

* fix variable types

* format

* mpre Phs enum

* fix merge errors

* fix gamepad stopPatternedRumble

* format

* delete leftover files from merge

* move asm to correct folder

* revert f_pc from C to CPP

* remove C hacks and format

* format

* OK
This commit is contained in:
lepelog
2020-12-31 21:12:29 +01:00
committed by GitHub
parent bf652784d1
commit 5ffa0945b0
94 changed files with 1840 additions and 2646 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/d/d_a/d_a_alink.cpp
+1
View File
@@ -3,6 +3,7 @@
#include "SComponent/c_phase.h"
#include "Z2AudioLib/Z2SeMgr/Z2SeMgr.h"
#include "Z2AudioLib/Z2SeqMgr/Z2SeqMgr.h"
#include "f/f_pc/f_pc_manager.h"
#include "f/f_pc/f_pc_searcher.h"
u32 daAlink_c::getE3Zhint(void) {
src/f/f_pc/f_pc_base.cpp
+136 -1
View File
@@ -1 +1,136 @@
// ok
#include "f/f_pc/f_pc_base.h"
#include "SComponent/c_phase.h"
#include "dolphin/types.h"
#include "f/f_pc/f_pc_delete_tag.h"
#include "f/f_pc/f_pc_layer.h"
#include "f/f_pc/f_pc_layer_tag.h"
#include "f/f_pc/f_pc_line_tag.h"
#include "f/f_pc/f_pc_method.h"
#include "f/f_pc/f_pc_pause.h"
#include "f/f_pc/f_pc_priority.h"
#include "f/f_pc/f_pc_profile.h"
extern s32 lbl_80450D04; // f_pc_base::t_type
extern s8 lbl_80450D08;
extern s32 lbl_80450D0C; // f_pc_base::process_id
extern s8 lbl_80450D10;
extern s32 lbl_80450D00; // f_pc_base::g_fpcBs_type
extern "C" {
extern void cMl_NS_free(void* pPtr);
extern void* cMl_NS_memalignB(s32 pAlign, s32 pSize);
extern void sBs_ClearArea(void* pPtr, s32 pSize);
BOOL fpcBs_Is_JustOfType(s32 pType1, s32 pType2) {
return checkEqual(pType1, pType2);
}
s32 fpcBs_MakeOfType(s32* pType) {
if (lbl_80450D08 == 0) {
lbl_80450D04 = 0x9130000;
lbl_80450D08 = 1;
}
if (*pType == 0) {
*pType = ++lbl_80450D04;
}
return *pType;
}
s32 fpcBs_MakeOfId(void) {
if (lbl_80450D10 == 0) {
lbl_80450D0C = 1;
lbl_80450D10 = 1;
}
return lbl_80450D0C++;
}
s32 fpcBs_Execute(base_process_class* pProc) {
s32 result;
layer_class* savedLayer = fpcLy_CurrentLayer();
fpcLy_SetCurrentLayer(pProc->mLyTg.mpLayer);
result = fpcMtd_Execute(pProc->mpPcMtd, pProc);
fpcLy_SetCurrentLayer(savedLayer);
return result;
}
void fpcBs_DeleteAppend(base_process_class* pProc) {
if (pProc->mpUserData != NULL) {
cMl_NS_free(pProc->mpUserData);
pProc->mpUserData = NULL;
}
}
s32 fpcBs_IsDelete(base_process_class* pProc) {
s32 result;
layer_class* savedLayer = fpcLy_CurrentLayer();
fpcLy_SetCurrentLayer(pProc->mLyTg.mpLayer);
result = fpcMtd_IsDelete(pProc->mpPcMtd, pProc);
fpcLy_SetCurrentLayer(savedLayer);
return result;
}
s32 fpcBs_Delete(base_process_class* pProc) {
s32 deleteResult = fpcMtd_Delete(pProc->mpPcMtd, pProc);
if (deleteResult == 1) {
fpcBs_DeleteAppend(pProc);
pProc->mBsType = 0;
cMl_NS_free(pProc);
}
return deleteResult;
}
base_process_class* fpcBs_Create(s16 pProcTypeID, u32 pProcID, void* pData) {
process_profile_definition* procProfDef;
base_process_class* procClass;
s32 size;
procProfDef = fpcPf_Get(pProcTypeID);
size = procProfDef->mSize + procProfDef->mSizeOther;
procClass = (base_process_class*)cMl_NS_memalignB(-4, size);
if (procClass == NULL) {
return NULL;
} else {
sBs_ClearArea(procClass, size);
fpcLyTg_Init(&procClass->mLyTg, procProfDef->mLayerID, procClass);
fpcLnTg_Init(&procClass->mLnTg, procClass);
fpcDtTg_Init(&procClass->mDtTg, procClass);
fpcPi_Init(&procClass->mPi, procClass, procProfDef->mLayerID, procProfDef->mListID,
procProfDef->mListPrio);
procClass->mInitState = 0;
procClass->mUnk0 = 0;
procClass->mBsPcId = pProcID;
procClass->mBsTypeId = pProcTypeID;
procClass->mBsType = fpcBs_MakeOfType(&lbl_80450D00);
procClass->mProcName = procProfDef->mProcName;
fpcPause_Init(procClass);
procClass->mpPcMtd = procProfDef->mpPcMtd;
procClass->mpProf = procProfDef;
procClass->mpUserData = pData;
procClass->mParameters = procProfDef->mParameters;
return procClass;
}
}
s32 fpcBs_SubCreate(base_process_class* pProc) {
switch (fpcMtd_Create(pProc->mpPcMtd, pProc)) {
case 2:
case cPhs_COMPLEATE_e:
fpcBs_DeleteAppend(pProc);
pProc->mUnk2 = 2;
return 2;
case cPhs_ZERO_e:
case 1:
pProc->mInitState = 1;
pProc->mUnk2 = 0;
return cPhs_ZERO_e;
case 3:
pProc->mUnk2 = 3;
return 3;
case cPhs_ERROR_e:
default:
pProc->mUnk2 = 5;
return cPhs_ERROR_e;
}
}
}
src/f/f_pc/f_pc_create_iter.cpp
+32 -1
View File
@@ -1 +1,32 @@
// ok
#include "f/f_pc/f_pc_create_iter.h"
// g_fpcCtTg_Queue
extern node_list_class lbl_803A3990;
extern "C" {
s32 fpcCtIt_Method(cNdIt_MethodFunc pJudge, void* pUserData) {
node_method_data iter;
iter.mFunc = pJudge;
iter.mpUserData = pUserData;
return cLsIt_Method(&lbl_803A3990, (cNdIt_MethodFunc)cTgIt_MethodCall, &iter);
}
void* fpcCtIt_Judge(cNdIt_JudgeFunc pJudge, void* pUserData) {
node_judge_data iter;
iter.mFunc = pJudge;
iter.mpUserData = pUserData;
return cLsIt_Judge(&lbl_803A3990, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &iter);
}
asm void* fpcCtIt_filter_JudgeInLayer(create_tag*, fpcCtIt_jilprm_c*) {
nofralloc
#include "f/f_pc/asm/80020A40.s"
}
void* fpcCtIt_JudgeInLayer(u32 pUnk0, cNdIt_JudgeFunc pFunc, void* pUserData) {
fpcCtIt_jilprm_c data;
data.mUnk0 = pUnk0;
data.mFunc = pFunc;
data.mpUserData = pUserData;
return fpcCtIt_Judge((cNdIt_JudgeFunc)fpcCtIt_filter_JudgeInLayer, &data);
}
}
src/f/f_pc/f_pc_create_req.cpp
+34 -45
View File
@@ -1,9 +1,9 @@
#include "f/f_pc/f_pc_create_req.h"
#include "dolphin/types.h"
#include "SComponent/c_phase.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_create_iter.h"
#include "f/f_pc/f_pc_create_req.h"
#include "f/f_pc/f_pc_deletor.h"
#include "f/f_pc/f_pc_executor.h"
#include "f/f_pc/f_pc_layer.h"
@@ -11,17 +11,17 @@
extern "C" {
bool fpcCtRq_isCreatingByID(create_tag* pTag, int* pId) {
create_request* pReq = (create_request*)(pTag->mpTagData);
return pReq->mBsPcId == *pId;
BOOL fpcCtRq_isCreatingByID(create_tag* pTag, s32* pId) {
create_request* pReq = (create_request*)(pTag->mBase.mpTagData);
return checkEqual(*pId, pReq->mBsPcId);
}
bool fpcCtRq_IsCreatingByID(unsigned int id) {
return fpcCtIt_Judge((cNdIt_JudgeFunc)fpcCtRq_isCreatingByID, &id) != NULL;
BOOL fpcCtRq_IsCreatingByID(u32 id) {
return fpcCtIt_Judge((cNdIt_JudgeFunc)fpcCtRq_isCreatingByID, &id) != NULL ? 1 : 0;
}
void fpcCtRq_CreateQTo(create_request* pReq) {
fpcCtTg_CreateQTo(pReq);
fpcCtTg_CreateQTo(&pReq->mBase.mBase);
fpcLy_CreatedMesg(pReq->mpLayer);
fpcLy_CancelQTo(&pReq->mMtdTg);
}
@@ -29,73 +29,64 @@ void fpcCtRq_CreateQTo(create_request* pReq) {
void fpcCtRq_ToCreateQ(create_request* pReq) {
fpcLy_CreatingMesg(pReq->mpLayer);
fpcLy_ToCancelQ(pReq->mpLayer, &pReq->mMtdTg);
fpcCtTg_ToCreateQ(pReq);
fpcCtTg_ToCreateQ(&pReq->mBase.mBase);
}
extern void cMl_NS_free(void* pPtr);
#if NON_MATCHING
bool fpcCtRq_Delete(create_request* pReq) {
BOOL fpcCtRq_Delete(create_request* pReq) {
fpcCtRq_CreateQTo(pReq);
if (pReq->mpCtRqMtd != NULL) {
// flow control
if (fpcMtd_Method(pReq->mpCtRqMtd->mpDelete, pReq) == 0)
return 0;
if (pReq->mpRes)
if (pReq->mpCtRqMtd != NULL && fpcMtd_Method(pReq->mpCtRqMtd->mpDelete, pReq) == 0) {
return 0;
} else {
if (pReq->mpRes) {
pReq->mpRes->mpCtRq = NULL;
}
cMl_NS_free(pReq);
return 1;
}
return 0;
}
#else
asm bool fpcCtRq_Delete(create_request* pReq) {
nofralloc
#include "f/f_pc/f_pc_create_req/asm/func_80020BA0.s"
}
#endif
bool fpcCtRq_Cancel(create_request* pReq) {
BOOL fpcCtRq_Cancel(create_request* pReq) {
base_process_class* pProc;
if (pReq != NULL && !pReq->mbIsCancelling) {
pReq->mbIsCancelling = true;
base_process_class* pProc = pReq->mpRes;
pReq->mbIsCancelling = TRUE;
pProc = pReq->mpRes;
if (pProc != NULL && !fpcDt_Delete(pProc))
return false;
return FALSE;
if (pReq->mpCtRqMtd != NULL && !fpcMtd_Method(pReq->mpCtRqMtd->mpCancel, pReq))
return false;
return FALSE;
return fpcCtRq_Delete(pReq);
} else {
return true;
return TRUE;
}
}
int fpcCtRq_IsDoing(create_request* pReq) {
s32 fpcCtRq_IsDoing(create_request* pReq) {
if (pReq != NULL)
return pReq->mbIsCreating;
else
return false;
return FALSE;
}
static bool fpcCtRq_Do(create_request* pReq) {
int ret = cPhs_COMPLEATE_e;
BOOL fpcCtRq_Do(create_request* pReq) {
s32 ret = cPhs_COMPLEATE_e;
if (pReq->mpCtRqMtd != NULL) {
cPhs__Handler pHandler = pReq->mpCtRqMtd->mpHandler;
if (pHandler != NULL) {
pReq->mbIsCreating = true;
pReq->mbIsCreating = TRUE;
ret = pHandler(pReq);
pReq->mbIsCreating = false;
pReq->mbIsCreating = FALSE;
}
}
switch (ret) {
case cPhs_COMPLEATE_e: {
int success = fpcEx_ToExecuteQ(pReq->mpRes);
s32 success = fpcEx_ToExecuteQ(pReq->mpRes);
if (success == 0)
return fpcCtRq_Cancel(pReq);
else
@@ -113,24 +104,22 @@ void fpcCtRq_Handler(void) {
fpcCtIt_Method((cNdIt_MethodFunc)fpcCtRq_Do, NULL);
}
extern void* cMl_NS_memalignB(int, unsigned long);
extern int fpcBs_MakeOfId(void);
extern void* cMl_NS_memalignB(s32, u32);
create_request* fpcCtRq_Create(layer_class* pLayer, unsigned long size,
create_request_method_class* pMthd) {
create_request* fpcCtRq_Create(layer_class* pLayer, u32 size, create_request_method_class* pMthd) {
create_request* pReq = (create_request*)cMl_NS_memalignB(-4, size);
if (pReq != NULL) {
fpcCtTg_Init(pReq, pReq);
fpcCtTg_Init(&pReq->mBase, pReq);
fpcMtdTg_Init(&pReq->mMtdTg, (process_method_tag_func)fpcCtRq_Cancel, pReq);
pReq->mpLayer = pLayer;
pReq->mpCtRqMtd = pMthd;
pReq->mBsPcId = fpcBs_MakeOfId();
pReq->mpRes = NULL;
pReq->mbIsCancelling = false;
pReq->mbIsCancelling = FALSE;
fpcCtRq_ToCreateQ(pReq);
}
return pReq;
}
};
}
src/f/f_pc/f_pc_create_tag.cpp
+3 -4
View File
@@ -1,6 +1,5 @@
#include "f/f_pc/f_pc_create_tag.h"
#include "global.h"
// g_fpcCtTg_Queue
extern node_list_class lbl_803A3990;
@@ -15,8 +14,8 @@ void fpcCtTg_CreateQTo(create_tag_class* pTag) {
cTg_SingleCut(pTag);
}
int fpcCtTg_Init(create_tag* pTag, void* pUserData) {
cTg_Create(pTag, pUserData);
s32 fpcCtTg_Init(create_tag* pTag, void* pUserData) {
cTg_Create(&pTag->mBase, pUserData);
return 1;
}
};
}
src/f/f_pc/f_pc_creator.cpp
+6 -5
View File
@@ -1,23 +1,24 @@
#include "f/f_pc/f_pc_creator.h"
#include "dolphin/types.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_create_req.h"
extern "C" {
bool fpcCt_IsCreatingByID(unsigned int id) {
BOOL fpcCt_IsCreatingByID(u32 id) {
return fpcCtRq_IsCreatingByID(id);
}
int fpcCt_IsDoing(base_process_class* pProc) {
s32 fpcCt_IsDoing(base_process_class* pProc) {
return fpcCtRq_IsDoing(pProc->mpCtRq);
}
void fpcCt_Abort(base_process_class* pProc) {
fpcCtRq_Cancel(pProc->mpCtRq);
BOOL fpcCt_Abort(base_process_class* pProc) {
return fpcCtRq_Cancel(pProc->mpCtRq);
}
void fpcCt_Handler(void) {
fpcCtRq_Handler();
}
};
}
src/f/f_pc/f_pc_delete_tag.cpp
+11 -11
View File
@@ -1,29 +1,29 @@
#include "f/f_pc/f_pc_delete_tag.h"
#include "global.h"
#include "dolphin/types.h"
// g_fpcDtTg_Queue
extern node_list_class lbl_803A39A0;
extern "C" {
bool fpcDtTg_IsEmpty(delete_tag_class* pTag) {
return lbl_803A39A0.mSize == 0;
BOOL fpcDtTg_IsEmpty(void) {
return checkEqual(lbl_803A39A0.mSize, 0);
}
void fpcDtTg_ToDeleteQ(delete_tag_class* pTag) {
pTag->mTimer = 1;
cTg_Addition(&lbl_803A39A0, pTag);
cTg_Addition(&lbl_803A39A0, &pTag->mBase);
}
void fpcDtTg_DeleteQTo(delete_tag_class* pTag) {
cTg_SingleCut(pTag);
cTg_SingleCut(&pTag->mBase);
}
int fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc) {
s32 fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc) {
if (pTag->mTimer <= 0) {
s32 ret;
fpcDtTg_DeleteQTo(pTag);
int ret = pFunc(pTag->mpTagData);
ret = pFunc(pTag->mBase.mpTagData);
if (ret == 0) {
fpcDtTg_ToDeleteQ(pTag);
return 0;
@@ -36,8 +36,8 @@ int fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc) {
}
}
int fpcDtTg_Init(delete_tag_class* pTag, void* pUserData) {
cTg_Create(pTag, pUserData);
s32 fpcDtTg_Init(delete_tag_class* pTag, void* pUserData) {
cTg_Create(&pTag->mBase, pUserData);
return 1;
}
};
}
src/f/f_pc/f_pc_deletor.cpp
+94 -2
View File
@@ -1,11 +1,103 @@
#include "f/f_pc/f_pc_deletor.h"
#include "SComponent/c_list_iter.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_creator.h"
#include "f/f_pc/f_pc_executor.h"
#include "f/f_pc/f_pc_layer.h"
#include "f/f_pc/f_pc_layer_iter.h"
#include "f/f_pc/f_pc_node.h"
// g_fpcDtTg_Queue
extern node_list_class lbl_803A39A0;
// g_fpcNd_type
extern s32 lbl_80450D40;
extern "C" {
int fpcDt_Delete(base_process_class* pProc) {
BOOL fpcLd_Use(s16 procName);
s32 fpcLd_IsLoaded(s16 procName);
void fpcLd_Free(s16 procName);
s32 fpcLd_Load(s16 procName);
BOOL fpcDt_IsComplete() {
return fpcDtTg_IsEmpty();
}
s32 fpcDt_deleteMethod(base_process_class* pProc) {
layer_class* layer = pProc->mDtTg.mpLayer;
s16 typeID = pProc->mBsTypeId;
fpcLy_SetCurrentLayer(layer);
fpcLnTg_QueueTo(&pProc->mLnTg);
if (fpcBs_Delete(pProc) == 1) {
fpcLy_DeletedMesg(layer);
fpcLd_Free(typeID);
return 1;
} else {
return 0;
}
}
void fpcDt_Handler(void) {
cLsIt_Method(&lbl_803A39A0, (cNdIt_MethodFunc)fpcDtTg_Do, fpcDt_deleteMethod);
}
s32 fpcDt_ToQueue(base_process_class* pProc) {
if (pProc->mUnk0 != 1 && fpcBs_IsDelete(pProc) == 1) {
if (fpcPi_IsInQueue(&pProc->mPi) == 1) {
fpcPi_Delete(&pProc->mPi);
}
pProc->mDtTg.mpLayer = pProc->mLyTg.mpLayer;
fpcDtTg_ToDeleteQ(&pProc->mDtTg);
fpcLy_DeletingMesg(pProc->mLyTg.mpLayer);
return 1;
} else {
return 0;
}
}
s32 fpcDt_ToDeleteQ(base_process_class* pProc) {
if (pProc->mUnk0 == 1) {
return 0;
} else {
if (cTg_IsUse(&pProc->mDtTg.mBase) != 0) {
return 1;
} else {
if (fpcBs_Is_JustOfType(lbl_80450D40, pProc->mSubType) != 0) {
process_node_class* procNode = (process_node_class*)pProc;
if (fpcNd_IsDeleteTiming(procNode) == 0) {
return 0;
} else {
layer_class* layer = &procNode->mLayer;
fpcLy_Cancel(layer);
if (fpcLyIt_OnlyHereLY(layer, (cNdIt_MethodFunc)fpcDt_ToDeleteQ, NULL) == 0) {
return 0;
}
}
}
if (fpcDt_ToQueue(pProc) == 1) {
// return type has to be BOOL
if (fpcEx_IsExist(pProc->mBsPcId) == 1) {
if (fpcEx_ExecuteQTo(pProc) == 0) {
return 0;
}
} else {
// return type is wrong, has to be BOOL
if (fpcCt_Abort(pProc) == 0) {
return 0;
}
}
pProc->mInitState = 3;
return 1;
} else {
return 0;
}
}
}
}
s32 fpcDt_Delete(base_process_class* pProc) {
if (pProc != NULL) {
if (fpcCt_IsDoing(pProc) == 1)
return 0;
@@ -18,4 +110,4 @@ int fpcDt_Delete(base_process_class* pProc) {
return 1;
}
}
};
}
src/f/f_pc/f_pc_draw.cpp
+42 -1
View File
@@ -1 +1,42 @@
// ok
#include "f/f_pc/f_pc_draw.h"
#include "f/f_pc/f_pc_layer.h"
#include "f/f_pc/f_pc_pause.h"
// f_pc_leaf::g_fpcLf_type
extern s32 lbl_80450D30;
typedef s32 (*cNdIt_MethodFuncFunc)(cNdIt_MethodFunc);
extern "C" {
extern void cAPIGph_AfterOfDraw(void);
extern void cAPIGph_BeforeOfDraw(void);
s32 fpcDw_Execute(base_process_class* pProc) {
if (!fpcPause_IsEnable(pProc, 2)) {
layer_class* curLay;
s32 ret;
process_method_func func;
curLay = fpcLy_CurrentLayer();
if (fpcBs_Is_JustOfType(lbl_80450D30, pProc->mSubType)) {
func = ((nodedraw_method_class*)pProc->mpPcMtd)->mNodedrawFunc;
} else {
func = ((nodedraw_method_class*)pProc->mpPcMtd)->mNodedrawFunc;
}
fpcLy_SetCurrentLayer(pProc->mLyTg.mpLayer);
ret = func(pProc);
fpcLy_SetCurrentLayer(curLay);
return ret;
} else {
return 0;
}
}
s32 fpcDw_Handler(cNdIt_MethodFuncFunc param_1, cNdIt_MethodFunc param_2) {
s32 ret;
cAPIGph_BeforeOfDraw();
ret = param_1(param_2);
cAPIGph_AfterOfDraw();
return ret;
}
}
src/f/f_pc/f_pc_draw_priority.cpp
+4 -6
View File
@@ -1,18 +1,16 @@
#include "f/f_pc/f_pc_draw_priority.h"
#include "global.h"
extern "C" {
int fpcDwPi_Get(draw_priority_class* pDwPi) {
s32 fpcDwPi_Get(draw_priority_class* pDwPi) {
return pDwPi->mPriority;
}
void fpcDwPi_Set(draw_priority_class* pDwPi, int p) {
void fpcDwPi_Set(draw_priority_class* pDwPi, s32 p) {
pDwPi->mPriority = p;
}
void fpcDwPi_Init(draw_priority_class* pDwPi, int p) {
void fpcDwPi_Init(draw_priority_class* pDwPi, s32 p) {
fpcDwPi_Set(pDwPi, p);
}
};
}
src/f/f_pc/f_pc_executor.cpp
+18 -20
View File
@@ -1,4 +1,3 @@
#include "f/f_pc/f_pc_executor.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_layer.h"
@@ -8,12 +7,12 @@
#include "f/f_pc/f_pc_node.h"
#include "f/f_pc/f_pc_searcher.h"
// g_fpcNd_type
extern s32 lbl_80450D40;
extern "C" {
extern int fpcPause_IsEnable(base_process_class* pProc, int);
// g_fpcNd_type
extern int lbl_80450D40;
extern s32 fpcPause_IsEnable(base_process_class* pProc, s32);
base_process_class* fpcEx_Search(void* pFunc, void* pUserData) {
return (base_process_class*)fpcLyIt_AllJudge((cNdIt_MethodFunc)pFunc, pUserData);
@@ -27,23 +26,22 @@ base_process_class* fpcEx_SearchByID(u32 id) {
;
}
bool fpcEx_IsExist(int id) {
return fpcEx_SearchByID(id) != NULL;
BOOL fpcEx_IsExist(s32 id) {
return fpcEx_SearchByID(id) != NULL ? 1 : 0;
}
int fpcEx_Execute(base_process_class* pProc) {
s32 fpcEx_Execute(base_process_class* pProc) {
if (pProc->mInitState != 2 || fpcPause_IsEnable(pProc, 1) == 1)
return 0;
fpcBs_Execute(pProc);
// TODO: missing return?
return fpcBs_Execute(pProc);
}
int fpcEx_ToLineQ(base_process_class* pProc) {
s32 fpcEx_ToLineQ(base_process_class* pProc) {
layer_class* pLayer = pProc->mLyTg.mpLayer;
base_process_class* pLayerPcNode = pLayer->mpPcNode;
base_process_class* pLayerPcNode = &pLayer->mpPcNode->mBase;
if (pLayer->mLayerID == 0 || cTg_IsUse(&pLayerPcNode->mLnTg) == true) {
int ret = fpcLnTg_ToQueue(&pProc->mLnTg, pProc->mPi.mInfoCurr.mListID);
if (pLayer->mLayerID == 0 || cTg_IsUse(&pLayerPcNode->mLnTg.mBase) == TRUE) {
s32 ret = fpcLnTg_ToQueue(&pProc->mLnTg, pProc->mPi.mInfoCurr.mListID);
if (ret == 0) {
fpcLyTg_QueueTo(&pProc->mLyTg);
return 0;
@@ -61,8 +59,8 @@ int fpcEx_ToLineQ(base_process_class* pProc) {
return 0;
}
int fpcEx_ExecuteQTo(base_process_class* pProc) {
int ret = fpcLyTg_QueueTo(&pProc->mLyTg);
s32 fpcEx_ExecuteQTo(base_process_class* pProc) {
s32 ret = fpcLyTg_QueueTo(&pProc->mLyTg);
if (ret == 1) {
pProc->mInitState = 3;
return 1;
@@ -71,8 +69,8 @@ int fpcEx_ExecuteQTo(base_process_class* pProc) {
}
}
int fpcEx_ToExecuteQ(base_process_class* pProc) {
int ret = fpcLyTg_ToQueue(&pProc->mLyTg, pProc->mPi.mInfoCurr.mLayer,
s32 fpcEx_ToExecuteQ(base_process_class* pProc) {
s32 ret = fpcLyTg_ToQueue(&pProc->mLyTg, pProc->mPi.mInfoCurr.mLayer,
pProc->mPi.mInfoCurr.mListID, pProc->mPi.mInfoCurr.mListPrio);
if (ret == 1) {
fpcEx_ToLineQ(pProc);
@@ -83,6 +81,6 @@ int fpcEx_ToExecuteQ(base_process_class* pProc) {
}
void fpcEx_Handler(cNdIt_MethodFunc pFunc) {
return fpcLnIt_Queue(pFunc);
fpcLnIt_Queue(pFunc);
}
};
}
src/f/f_pc/f_pc_fstcreate_req.cpp
+55 -1
View File
@@ -1 +1,55 @@
// ok
#include "f/f_pc/f_pc_fstcreate_req.h"
#include "dolphin/types.h"
// f_pc_fstcreate_req::submethod$2214
extern create_request_method_class lbl_803A3AE0;
extern "C" {
BOOL fpcLd_Use(s16 procName);
s32 fpcLd_IsLoaded(s16 procName);
void fpcLd_Free(s16 procName);
s32 fpcLd_Load(s16 procName);
s32 fpcFCtRq_Do(fast_create_request* pFstCreateReq) {
if (pFstCreateReq->mpFastCreateFunc != NULL &&
pFstCreateReq->mpFastCreateFunc(pFstCreateReq->mBase.mpRes,
pFstCreateReq->mpFastCreateData) == 0) {
return 3;
} else {
return 4;
}
}
s32 fpcFCtRq_Delete(fast_create_request* ppFstCreateReq) {
return 1;
}
base_process_class* fpcFCtRq_Request(layer_class* pLayer, s16 pProcTypeID,
fstCreateFunc pFastCreateFunc, void* pFastCreateData,
void* pData) {
if (!fpcLd_Use(pProcTypeID)) {
return NULL;
} else {
fast_create_request* request =
(fast_create_request*)fpcCtRq_Create(pLayer, 0x50, &lbl_803A3AE0);
if (request != NULL) {
base_process_class* proc;
fpcLy_SetCurrentLayer(pLayer);
proc = fpcBs_Create(pProcTypeID, fpcBs_MakeOfId(), pData);
if (proc != NULL) {
proc->mpCtRq = (struct create_request*)request;
request->mBase.mpRes = proc;
request->mBase.mBsPcId = proc->mBsPcId;
if (fpcBs_SubCreate(proc) == 2) {
request->mpFastCreateFunc = pFastCreateFunc;
request->mpFastCreateData = pFastCreateData;
return proc;
}
}
fpcCtRq_Cancel(&request->mBase);
}
return NULL;
}
}
}
src/f/f_pc/f_pc_layer.cpp
+25 -25
View File
@@ -1,7 +1,7 @@
#include "f/f_pc/f_pc_layer.h"
#include "dolphin/types.h"
#include "f/f_pc/f_pc_method_iter.h"
#include "f/f_pc/f_pc_method_tag.h"
#include "global.h"
// f_pc_layer::l_fpcLy_CurrLayer_p
extern layer_class* lbl_80450D18;
@@ -22,51 +22,51 @@ void fpcLy_CancelQTo(process_method_tag_class* pMthd) {
fpcMtdTg_MethodQTo(pMthd);
}
int fpcLy_ToCancelQ(layer_class* pLayer, process_method_tag_class* pMthd) {
s32 fpcLy_ToCancelQ(layer_class* pLayer, process_method_tag_class* pMthd) {
return fpcMtdTg_ToMethodQ(&pLayer->mCancelList, pMthd);
}
bool fpcLy_CancelMethod(process_method_tag_class* pLayer) {
return fpcMtdTg_Do(pLayer) == 1;
BOOL fpcLy_CancelMethod(process_method_tag_class* pLayer) {
return checkEqual(1, fpcMtdTg_Do(pLayer));
}
int fpcLy_IntoQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag, int idx) {
s32 fpcLy_IntoQueue(layer_class* pLayer, s32 treeListIdx, create_tag_class* pTag, s32 idx) {
return cTg_InsertToTree(&pLayer->mNodeListTree, treeListIdx, pTag, idx);
}
int fpcLy_ToQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag) {
s32 fpcLy_ToQueue(layer_class* pLayer, s32 treeListIdx, create_tag_class* pTag) {
return cTg_AdditionToTree(&pLayer->mNodeListTree, treeListIdx, pTag);
}
int fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag) {
s32 fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag) {
return cTg_SingleCutFromTree(pTag);
}
bool fpcLy_IsDeletingMesg(layer_class* pLayer) {
return pLayer->mDeletingCount > 0;
BOOL fpcLy_IsDeletingMesg(layer_class* pLayer) {
return pLayer->counts.mDeletingCount > 0;
}
void fpcLy_DeletingMesg(layer_class* pLayer) {
pLayer->mDeletingCount++;
pLayer->counts.mDeletingCount++;
}
void fpcLy_DeletedMesg(layer_class* pLayer) {
if (pLayer->mDeletingCount > 0) {
pLayer->mDeletingCount--;
if (pLayer->counts.mDeletingCount > 0) {
pLayer->counts.mDeletingCount--;
}
}
bool fpcLy_IsCreatingMesg(layer_class* pLayer) {
return pLayer->mCreatingCount > 0;
BOOL fpcLy_IsCreatingMesg(layer_class* pLayer) {
return pLayer->counts.mCreatingCount > 0;
}
void fpcLy_CreatingMesg(layer_class* pLayer) {
pLayer->mCreatingCount++;
pLayer->counts.mCreatingCount++;
}
void fpcLy_CreatedMesg(layer_class* pLayer) {
if (pLayer->mCreatingCount > 0) {
pLayer->mCreatingCount--;
if (pLayer->counts.mCreatingCount > 0) {
pLayer->counts.mCreatingCount--;
}
}
@@ -82,7 +82,7 @@ layer_class* fpcLy_CurrentLayer(void) {
return lbl_80450D18;
}
layer_class* fpcLy_Search(unsigned int id) {
layer_class* fpcLy_Search(u32 id) {
layer_class* iVar1 = fpcLy_RootLayer();
while (iVar1 != NULL) {
if (iVar1->mLayerID == id) {
@@ -93,7 +93,7 @@ layer_class* fpcLy_Search(unsigned int id) {
return NULL;
}
layer_class* fpcLy_Layer(unsigned int id) {
layer_class* fpcLy_Layer(u32 id) {
if (id == 0 || fpcLy_RootLayer()->mLayerID == id) {
return fpcLy_RootLayer();
} else if (id == ~2 || fpcLy_CurrentLayer()->mLayerID == id) {
@@ -104,12 +104,12 @@ layer_class* fpcLy_Layer(unsigned int id) {
}
void fpcLy_Regist(layer_class* pLayer) {
cLs_Addition(&lbl_803A39DC, &pLayer->mNode);
cLs_Addition(&lbl_803A39DC, (node_class*)pLayer);
}
int fpcLy_Delete(layer_class* pLayer) {
s32 fpcLy_Delete(layer_class* pLayer) {
if (pLayer->mNodeListTree.mpLists->mSize == 0 && pLayer->mCancelList.mSize == 0) {
cLs_SingleCut(&pLayer->mNode);
cLs_SingleCut((node_class*)pLayer);
*pLayer = lbl_803A39B0;
return 1;
} else {
@@ -122,9 +122,9 @@ void fpcLy_Cancel(layer_class* pLayer) {
}
void fpcLy_Create(layer_class* pLayer, process_node_class* pPcNode, node_list_class* pLists,
int listNum) {
s32 listNum) {
void* pvVar1;
int iVar2;
s32 iVar2;
if (lbl_80450D20 == 0) {
lbl_80450D1C = 0x1; // IsInitOfLayerList
@@ -135,7 +135,7 @@ void fpcLy_Create(layer_class* pLayer, process_node_class* pPcNode, node_list_cl
lbl_80450D28 = 1;
}
*pLayer = lbl_803A39B0;
cNd_Create(&pLayer->mNode, NULL);
cNd_Create((node_class*)pLayer, NULL);
pLayer->mLayerID = lbl_80450D24++;
pLayer->mpPcNode = pPcNode;
if (lbl_80450D1C == 0x1) {
src/f/f_pc/f_pc_layer_iter.cpp
+5 -4
View File
@@ -4,15 +4,15 @@
extern "C" {
int fpcLyIt_OnlyHere(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData) {
s32 fpcLyIt_OnlyHere(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData) {
layer_iter lIter;
lIter.mpFunc = pFunc;
lIter.mpUserData = pUserData;
return cTrIt_Method(&pLayer->mNodeListTree, (cNdIt_MethodFunc)cTgIt_MethodCall, &lIter);
}
int fpcLyIt_OnlyHereLY(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData) {
int result;
s32 fpcLyIt_OnlyHereLY(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData) {
s32 result;
layer_class* currentLayer = fpcLy_CurrentLayer();
fpcLy_SetCurrentLayer(pLayer);
result = fpcLyIt_OnlyHere(pLayer, pFunc, pUserData);
@@ -29,10 +29,11 @@ void* fpcLyIt_Judge(layer_class* pLayer, cNdIt_MethodFunc pFunc, void* pUserData
void* fpcLyIt_AllJudge(cNdIt_MethodFunc pFunc, void* pUserData) {
layer_iter lIter;
layer_class* current;
lIter.mpFunc = pFunc;
lIter.mpUserData = pUserData;
layer_class* current = fpcLy_RootLayer();
current = fpcLy_RootLayer();
while (current != NULL) {
void* result =
cTrIt_Judge(&current->mNodeListTree, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &lIter);
src/f/f_pc/f_pc_layer_tag.cpp
+4 -3
View File
@@ -1,6 +1,6 @@
#include "f/f_pc/f_pc_layer_tag.h"
#include "dolphin/types.h"
#include "f/f_pc/f_pc_layer.h"
#include "global.h"
// f_pc_layer_tag::crear
extern layer_management_tag_class lbl_803A3A00;
@@ -16,7 +16,7 @@ s32 fpcLyTg_ToQueue(layer_management_tag_class* pTag, u32 layerID, u16 listID, u
pTag->mpLayer = fpcLy_Layer(layerID);
}
if (layerID == -1 || layerID == -3) {
int tmp = fpcLy_ToQueue(pTag->mpLayer, listID, &pTag->mCreateTag);
s32 tmp = fpcLy_ToQueue(pTag->mpLayer, listID, &pTag->mCreateTag);
if (tmp != 0x0) {
pTag->mNodeListID = listID;
pTag->mNodeListIdx = tmp - 1;
@@ -55,9 +55,10 @@ s32 fpcLyTg_Move(layer_management_tag_class* pTag, u32 layerID, u16 listID, u16
}
s32 fpcLyTg_Init(layer_management_tag_class* pTag, u32 param2, void* param3) {
layer_class* layer;
*pTag = lbl_803A3A00;
cTg_Create(&pTag->mCreateTag, param3);
layer_class* layer = fpcLy_Layer(param2);
layer = fpcLy_Layer(param2);
if (layer != NULL) {
pTag->mpLayer = layer;
return 1;
src/f/f_pc/f_pc_leaf.cpp
+37 -9
View File
@@ -1,23 +1,51 @@
#include "f/f_pc/f_pc_leaf.h"
#include "dolphin/types.h"
// f_pc_leaf::g_fpcLf_type
extern s32 lbl_80450D30;
extern "C" {
int fpcLf_GetPriority(leafdraw_class* pLeaf) {
s32 fpcLf_GetPriority(leafdraw_class* pLeaf) {
return fpcDwPi_Get(&pLeaf->mDwPi);
}
int fpcLf_DrawMethod(leafdraw_method_class* pMthd, void* pUserData) {
s32 fpcLf_DrawMethod(leafdraw_method_class* pMthd, void* pUserData) {
return fpcMtd_Method(pMthd->mpDrawFunc, pUserData);
}
#if 0
int fpcLf_Draw(leafdraw_class *pLeaf)
{
int ret = 0;
s32 fpcLf_Draw(leafdraw_class* pLeaf) {
s32 ret = 0;
if (pLeaf->mbUnk0 == 0)
ret = fpcLf_DrawMethod(pLeaf->mpDrawMtd, pLeaf);
return ret;
}
#endif
};
s32 fpcLf_Execute(leafdraw_class* pLeaf) {
return fpcMtd_Execute(&pLeaf->mpDrawMtd->mBase, pLeaf);
}
s32 fpcLf_IsDelete(leafdraw_class* pLeaf) {
return fpcMtd_IsDelete(&pLeaf->mpDrawMtd->mBase, pLeaf);
}
s32 fpcLf_Delete(leafdraw_class* pLeaf) {
s32 ret = fpcMtd_Delete(&pLeaf->mpDrawMtd->mBase, pLeaf);
if (ret == 1) {
pLeaf->mBase.mSubType = 0;
}
return ret;
}
s32 fpcLf_Create(leafdraw_class* pLeaf) {
leaf_process_profile_definition* profDef;
if (pLeaf->mBase.mInitState == 0) {
profDef = (leaf_process_profile_definition*)pLeaf->mBase.mpProf;
pLeaf->mpDrawMtd = profDef->mLfDrwMth;
pLeaf->mBase.mSubType = fpcBs_MakeOfType(&lbl_80450D30);
fpcDwPi_Init(&pLeaf->mDwPi, profDef->unk20);
pLeaf->mbUnk0 = 0;
}
return fpcMtd_Create(&pLeaf->mpDrawMtd->mBase, pLeaf);
}
}
src/f/f_pc/f_pc_line.cpp
+2 -2
View File
@@ -8,9 +8,9 @@ extern node_list_class lbl_803F4CF0[16];
extern "C" {
void fpcLn_Create(void) {
int i = ARRAY_SIZE(lbl_803F4CF0);
s32 i = ARRAY_SIZE(lbl_803F4CF0);
node_list_class* pLine = lbl_803F4CF0;
while (i-- > 0)
cLs_Create(pLine++);
}
};
}
src/f/f_pc/f_pc_line_iter.cpp
+4 -3
View File
@@ -9,12 +9,13 @@ extern node_lists_tree_class lbl_804505D8;
extern "C" {
static int fpcLnIt_MethodCall(create_tag_class* pTag, method_filter* pFilter) {
static s32 fpcLnIt_MethodCall(create_tag_class* pTag, method_filter* pFilter) {
layer_class* pLayer = ((base_process_class*)pTag->mpTagData)->mLyTg.mpLayer;
layer_class* pCurLayer = fpcLy_CurrentLayer();
s32 ret;
fpcLy_SetCurrentLayer(pLayer);
int ret = cTgIt_MethodCall(pTag, pFilter);
ret = cTgIt_MethodCall(pTag, pFilter);
fpcLy_SetCurrentLayer(pCurLayer);
return ret;
@@ -26,4 +27,4 @@ void fpcLnIt_Queue(cNdIt_MethodFunc pFunc) {
filter.mpUserData = NULL;
cTrIt_Method(&lbl_804505D8, (cNdIt_MethodFunc)fpcLnIt_MethodCall, &filter);
}
};
}
src/f/f_pc/f_pc_line_tag.cpp
+6 -6
View File
@@ -6,7 +6,7 @@ extern node_lists_tree_class lbl_804505D8;
extern "C" {
int fpcLnTg_Move(line_tag* pLineTag, int newLineListID) {
s32 fpcLnTg_Move(line_tag* pLineTag, s32 newLineListID) {
if (pLineTag->mLineListID != newLineListID) {
fpcLnTg_QueueTo(pLineTag);
return fpcLnTg_ToQueue(pLineTag, newLineListID);
@@ -16,12 +16,12 @@ int fpcLnTg_Move(line_tag* pLineTag, int newLineListID) {
}
void fpcLnTg_QueueTo(line_tag* pLineTag) {
cTg_SingleCutFromTree(pLineTag);
cTg_SingleCutFromTree(&pLineTag->mBase);
pLineTag->mLineListID = -1;
}
int fpcLnTg_ToQueue(line_tag* pLineTag, int lineListID) {
int ret = cTg_AdditionToTree(&lbl_804505D8, lineListID, pLineTag);
s32 fpcLnTg_ToQueue(line_tag* pLineTag, s32 lineListID) {
s32 ret = cTg_AdditionToTree(&lbl_804505D8, lineListID, &pLineTag->mBase);
if (ret) {
pLineTag->mLineListID = lineListID;
@@ -32,7 +32,7 @@ int fpcLnTg_ToQueue(line_tag* pLineTag, int lineListID) {
}
void fpcLnTg_Init(line_tag* pLineTag, void* pData) {
cTg_Create(pLineTag, pData);
cTg_Create(&pLineTag->mBase, pData);
pLineTag->mLineListID = -1;
}
};
}
src/f/f_pc/f_pc_load.cpp
+12 -11
View File
@@ -1,20 +1,21 @@
#include "f/f_pc/f_pc_load.h"
#include "SComponent/c_phase.h"
#include "dolphin/types.h"
extern "C" {
extern int cDyl_IsLinked(short procName);
extern int cDyl_Unlink(short procName);
extern int cDyl_LinkASync(short procName);
extern s32 cDyl_IsLinked(s16 procName);
extern s32 cDyl_Unlink(s16 procName);
extern s32 cDyl_LinkASync(s16 procName);
bool fpcLd_Use(u16 procName) {
if (fpcLd_IsLoaded(procName) == true && fpcLd_Load(procName) == cPhs_COMPLEATE_e)
return true;
return false;
BOOL fpcLd_Use(u16 procName) {
if (fpcLd_IsLoaded(procName) == TRUE && fpcLd_Load(procName) == cPhs_COMPLEATE_e)
return TRUE;
return FALSE;
}
int fpcLd_IsLoaded(u16 procName) {
s32 fpcLd_IsLoaded(u16 procName) {
return cDyl_IsLinked(procName);
}
@@ -22,8 +23,8 @@ void fpcLd_Free(u16 procName) {
cDyl_Unlink(procName);
}
int fpcLd_Load(u16 procName) {
int phase = cDyl_LinkASync(procName);
s32 fpcLd_Load(u16 procName) {
s32 phase = cDyl_LinkASync(procName);
switch (phase) {
case cPhs_COMPLEATE_e:
@@ -34,4 +35,4 @@ int fpcLd_Load(u16 procName) {
return cPhs_ERROR_e;
}
}
};
}
src/f/f_pc/f_pc_manager.cpp
+132 -1
View File
@@ -1 +1,132 @@
// ok
#include "f/f_pc/f_pc_manager.h"
#include "SComponent/c_tag.h"
#include "d/d_com/d_com_inf_game/d_com_inf_game.h"
#include "d/d_lib/d_lib.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_creator.h"
#include "f/f_pc/f_pc_delete_tag.h"
#include "f/f_pc/f_pc_deletor.h"
#include "f/f_pc/f_pc_executor.h"
#include "f/f_pc/f_pc_layer_iter.h"
#include "f/f_pc/f_pc_layer_tag.h"
#include "f/f_pc/f_pc_line.h"
#include "f/f_pc/f_pc_line_iter.h"
#include "f/f_pc/f_pc_line_tag.h"
#include "f/f_pc/f_pc_method.h"
#include "f/f_pc/f_pc_node_req.h"
#include "f/f_pc/f_pc_pause.h"
#include "f/f_pc/f_pc_priority.h"
#include "f/f_pc/f_pc_profile.h"
#include "global.h"
#include "m_Do/m_Do_controller_pad/m_Do_controller_pad.h"
extern "C" {
extern u8 lbl_80450D38;
extern s8 lbl_80450D39;
extern u8 lbl_80450EC4;
extern layer_class lbl_803F4DB0; // f_pc_manager::rootlayer$3716
extern node_list_class lbl_803F4DDC; // f_pc_manager::queue$3717
extern void fpcDw_Execute(base_process_class* pProc);
extern void fpcDw_Handler(void*, void*);
extern base_process_class* fpcFCtRq_Request(layer_class* pLayer, s16 pProcTypeID,
FastCreateReqFunc param_3, void* param_4, void* pData);
extern void* fpcCtIt_JudgeInLayer(u32 pLayerID, cNdIt_MethodFunc pFunc, void* pUserData);
void fpcM_Draw(void* pProc) {
fpcDw_Execute((base_process_class*)pProc);
}
s32 fpcM_DrawIterater(cNdIt_MethodFunc pFunc) {
return fpcLyIt_OnlyHere(fpcLy_RootLayer(), pFunc, NULL);
}
void fpcM_Execute(void* pProc) {
fpcEx_Execute((base_process_class*)pProc);
}
void fpcM_Delete(void* pProc) {
fpcDt_Delete((base_process_class*)pProc);
}
BOOL fpcM_IsCreating(u32 pID) {
return fpcCt_IsCreatingByID(pID);
}
typedef void (*fpcM_ManagementFunc)(void);
void fpcM_Management(fpcM_ManagementFunc pFunc1, fpcM_ManagementFunc pFunc2) {
MtxInit();
dDlst_peekZ_c_NS_peekData(&g_dComIfG_gameInfo.draw_list_list.dlstPeekZ);
if (!dShutdownErrorMsg_c_NS_execute()) {
if (lbl_80450D39 == 0) {
lbl_80450D38 = 0;
lbl_80450D39 = 1;
}
if (!dDvdErrorMsg_c_NS_execute()) {
if (lbl_80450D38 != 0) {
dLib_time_c::startTime();
Z2SoundMgr_NS_pauseAllGameSound(lbl_80450B60, false);
lbl_80450D38 = 0;
}
cAPIGph_Painter();
if ((lbl_80450EC4 & 1) == 0) {
fpcDt_Handler();
} else {
lbl_80450EC4 &= ~1;
}
fpcPi_Handler();
fpcCt_Handler();
if (pFunc1 != NULL) {
pFunc1();
}
fpcEx_Handler((cNdIt_MethodFunc)fpcM_Execute);
fpcDw_Handler((void*)fpcM_DrawIterater, fpcM_Draw);
if (pFunc2 != NULL) {
pFunc2();
}
dComIfG_play_c_NS_drawSimpleModel(&g_dComIfG_gameInfo.play);
} else if (lbl_80450D38 == 0) {
dLib_time_c::stopTime();
Z2SoundMgr_NS_pauseAllGameSound(lbl_80450B60, true);
lbl_803DD2D8[0]->stopPatternedRumble();
lbl_80450D38 = 1;
}
}
}
void fpcM_Init(void) {
fpcLy_Create(&lbl_803F4DB0, NULL, &lbl_803F4DDC, 10);
fpcLn_Create();
}
base_process_class* fpcM_FastCreate(s16 pProcTypeID, FastCreateReqFunc param_2, void* param_3,
void* pData) {
return fpcFCtRq_Request(fpcLy_CurrentLayer(), pProcTypeID, param_2, param_3, pData);
}
s32 fpcM_IsPause(void* pProc, u8 param_2) {
return fpcPause_IsEnable((base_process_class*)pProc, param_2 & 0xFF);
}
void fpcM_PauseEnable(void* pProc, u8 param_2) {
fpcPause_Enable((process_node_class*)pProc, param_2 & 0xFF);
}
void fpcM_PauseDisable(void* pProc, u8 param_2) {
fpcPause_Disable((process_node_class*)pProc, param_2 & 0xFF);
}
void* fpcM_JudgeInLayer(u32 pLayerID, cNdIt_MethodFunc pFunc, void* pUserData) {
layer_class* layer = fpcLy_Layer(pLayerID);
if (layer != NULL) {
void* ret = fpcCtIt_JudgeInLayer(pLayerID, pFunc, pUserData);
if (ret == NULL) {
ret = fpcLyIt_Judge(layer, pFunc, pUserData);
}
return ret;
} else {
return NULL;
}
}
}
src/f/f_pc/f_pc_method.cpp
+7 -7
View File
@@ -1,29 +1,29 @@
#include "f/f_pc/f_pc_method.h"
#include "global.h"
#include "dolphin/types.h"
extern "C" {
int fpcMtd_Method(process_method_func pFunc, void* pUserData) {
s32 fpcMtd_Method(process_method_func pFunc, void* pUserData) {
if (pFunc != NULL)
return pFunc(pUserData);
else
return 1;
}
int fpcMtd_Execute(process_method_class* pMthd, void* pUserData) {
s32 fpcMtd_Execute(process_method_class* pMthd, void* pUserData) {
return fpcMtd_Method(pMthd->mpExecuteFunc, pUserData);
}
int fpcMtd_IsDelete(process_method_class* pMthd, void* pUserData) {
s32 fpcMtd_IsDelete(process_method_class* pMthd, void* pUserData) {
return fpcMtd_Method(pMthd->mpIsDeleteFunc, pUserData);
}
int fpcMtd_Delete(process_method_class* pMthd, void* pUserData) {
s32 fpcMtd_Delete(process_method_class* pMthd, void* pUserData) {
return fpcMtd_Method(pMthd->mpDeleteFunc, pUserData);
}
int fpcMtd_Create(process_method_class* pMthd, void* pUserData) {
s32 fpcMtd_Create(process_method_class* pMthd, void* pUserData) {
return fpcMtd_Method(pMthd->mpCreateFunc, pUserData);
}
};
}
src/f/f_pc/f_pc_method_iter.cpp
+2 -3
View File
@@ -1,10 +1,9 @@
#include "f/f_pc/f_pc_method_iter.h"
#include "global.h"
#include "dolphin/types.h"
extern "C" {
void fpcMtdIt_Method(node_list_class* pList, cNdIt_MethodFunc pMethod) {
cLsIt_Method(pList, pMethod, NULL);
}
};
}
src/f/f_pc/f_pc_method_tag.cpp
+7 -7
View File
@@ -6,22 +6,22 @@ extern node_lists_tree_class lbl_804505D8;
extern "C" {
int fpcMtdTg_Do(process_method_tag_class* pMthd) {
s32 fpcMtdTg_Do(process_method_tag_class* pMthd) {
return pMthd->mpFunc(pMthd->mpMthdData);
}
int fpcMtdTg_ToMethodQ(node_list_class* pList, process_method_tag_class* pMthd) {
return cTg_Addition(pList, pMthd);
s32 fpcMtdTg_ToMethodQ(node_list_class* pList, process_method_tag_class* pMthd) {
return cTg_Addition(pList, &pMthd->mCreateTag);
}
void fpcMtdTg_MethodQTo(process_method_tag_class* pMthd) {
cTg_SingleCut(pMthd);
cTg_SingleCut(&pMthd->mCreateTag);
}
int fpcMtdTg_Init(process_method_tag_class* pMthd, process_method_tag_func pFunc, void* pMthdData) {
cTg_Create(pMthd, pMthd);
s32 fpcMtdTg_Init(process_method_tag_class* pMthd, process_method_tag_func pFunc, void* pMthdData) {
cTg_Create(&pMthd->mCreateTag, pMthd);
pMthd->mpFunc = pFunc;
pMthd->mpMthdData = pMthdData;
return 1;
}
};
}
src/f/f_pc/f_pc_node.cpp
+94 -1
View File
@@ -1 +1,94 @@
// ok
#include "f/f_pc/f_pc_node.h"
#include "dolphin/types.h"
#include "f/f_pc/f_pc_layer_iter.h"
// g_fpcNd_type
extern s32 lbl_80450D40;
// f_pc_node::g_fpcNd_IsCheckOfDeleteTiming
extern s32 lbl_804505E0;
extern "C" {
s32 fpcNd_DrawMethod(nodedraw_method_class* pNodeMethod, void* pData) {
return fpcMtd_Method(pNodeMethod->mNodedrawFunc, pData);
}
s32 fpcNd_Draw(process_node_class* pProcNode) {
s32 uVar2 = 0x0;
if (pProcNode->mUnk0 == 0) {
layer_class* uVar1 = fpcLy_CurrentLayer();
fpcLy_SetCurrentLayer(&pProcNode->mLayer);
uVar2 = fpcNd_DrawMethod(pProcNode->mpNodeMtd, pProcNode);
fpcLy_SetCurrentLayer(uVar1);
}
return uVar2;
}
s32 fpcNd_Execute(process_node_class* pProcNode) {
s32 ret;
layer_class* uVar1 = fpcLy_CurrentLayer();
fpcLy_SetCurrentLayer(&pProcNode->mLayer);
ret = fpcMtd_Execute(&pProcNode->mpNodeMtd->mBase, pProcNode);
fpcLy_SetCurrentLayer(uVar1);
return ret;
}
void* fpcNd_IsCreatingFromUnder(process_node_class* pProcNode) {
layer_class* layer;
if (pProcNode != NULL &&
fpcBs_Is_JustOfType(lbl_80450D40, pProcNode->mBase.mSubType) != FALSE) {
layer = &pProcNode->mLayer;
if (fpcLy_IsCreatingMesg(layer) == 0x0) {
return (process_node_class*)fpcLyIt_Judge(
layer, (cNdIt_MethodFunc)fpcNd_IsCreatingFromUnder, NULL);
} else {
return pProcNode;
}
} else {
return NULL;
}
}
s32 fpcNd_IsDeleteTiming(process_node_class* pProcNode) {
if (lbl_804505E0 == 0x1 && fpcNd_IsCreatingFromUnder(pProcNode) != NULL) {
return 0;
} else {
return 1;
}
}
s32 fpcNd_IsDelete(process_node_class* pProcNode) {
return fpcMtd_IsDelete(&pProcNode->mpNodeMtd->mBase, pProcNode);
}
s32 fpcNd_Delete(process_node_class* pProcNode) {
if ((fpcLy_IsDeletingMesg(&pProcNode->mLayer) == 0x0) &&
fpcMtd_Delete(&pProcNode->mpNodeMtd->mBase, pProcNode) == 0x1) {
pProcNode->mBase.mSubType = 0x0;
return fpcLy_Delete(&pProcNode->mLayer);
} else {
return 0;
}
}
s32 fpcNd_Create(process_node_class* pProcNode1) {
// this cast looks like a fake match, but it doesn't match without the cast, naive approach
// swaps r31 and r30 most likely it gets casted to another unknown struct
process_node_class* pProcNode = (process_node_class*)pProcNode1;
layer_class* uVar2;
s32 uVar3;
if (pProcNode->mBase.mInitState == 0) {
node_process_profile_definition* pProcProfileDef =
(node_process_profile_definition*)pProcNode->mBase.mpProf;
pProcNode->mBase.mSubType = fpcBs_MakeOfType(&lbl_80450D40);
pProcNode->mpNodeMtd = pProcProfileDef->mNDrwMthCls;
fpcLy_Create(&pProcNode->mLayer, pProcNode, pProcNode->mLayerNodeLists, 0x10);
pProcNode->mUnk0 = 0;
}
uVar2 = fpcLy_CurrentLayer();
fpcLy_SetCurrentLayer(&pProcNode->mLayer);
uVar3 = fpcMtd_Create(&pProcNode->mpNodeMtd->mBase, pProcNode);
fpcLy_SetCurrentLayer(uVar2);
return uVar3;
}
}
src/f/f_pc/f_pc_node_req.cpp
+309 -1
View File
@@ -1 +1,309 @@
// ok
#include "f/f_pc/f_pc_node_req.h"
#include "dolphin/types.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_create_req.h"
#include "f/f_pc/f_pc_creator.h"
#include "f/f_pc/f_pc_deletor.h"
#include "f/f_pc/f_pc_executor.h"
#include "f/f_pc/f_pc_layer.h"
// f_pc_node_req::l_fpcNdRq_Queue
extern node_list_class lbl_803A3A38;
// f_pc_node_req::clear$2359
extern node_create_request lbl_803A3A44;
// f_pc_node_req::methods$2376
extern cPhs__Handler lbl_803A3AA8[6];
// f_pc_node_req::methods$2386
extern cPhs__Handler lbl_803A3AC0[4];
// f_pc_node_req::methods$2397
extern cPhs__Handler lbl_803A3AD0[4];
// f_pc_node_req::request_id$2360
extern s32 lbl_80450D48;
extern s8 lbl_80450D4C;
extern "C" {
extern void cMl_NS_free(void*);
extern s32 fpcSCtRq_Request(layer_class*, s16, process_method_func, void*, void*);
extern void sBs_ClearArea(void* pPtr, s32 pSize);
extern void* cMl_NS_memalignB(s32 pAlign, s32 pSize);
void fpcNdRq_RequestQTo(node_create_request* pNodeCreateReq) {
fpcLy_CreatedMesg(pNodeCreateReq->mpLayerClass);
fpcLy_CancelQTo(&pNodeCreateReq->mProcMthCls);
cTg_SingleCut(&pNodeCreateReq->mCreateTag);
}
void fpcNdRq_ToRequestQ(node_create_request* pNodeCreateReq) {
cTg_Addition(&lbl_803A3A38, &pNodeCreateReq->mCreateTag);
fpcLy_ToCancelQ(pNodeCreateReq->mpLayerClass, &pNodeCreateReq->mProcMthCls);
fpcLy_CreatingMesg(pNodeCreateReq->mpLayerClass);
}
s32 fpcNdRq_phase_IsCreated(node_create_request* pNodeCreateReq) {
if (fpcCtRq_IsCreatingByID(pNodeCreateReq->mCreatingID) == TRUE) {
return cPhs_ZERO_e;
} else {
return fpcEx_IsExist(pNodeCreateReq->mCreatingID) == TRUE ? 2 : 3;
}
}
s32 fpcNdRq_phase_Create(node_create_request* pNodeCreateReq) {
pNodeCreateReq->mCreatingID =
fpcSCtRq_Request(pNodeCreateReq->mpLayerClass, pNodeCreateReq->mProcName,
pNodeCreateReq->mpNodeCrReqMthCls->mpPostMethodFunc, pNodeCreateReq,
pNodeCreateReq->mpUserData);
return pNodeCreateReq->mCreatingID == -1 ? 3 : 2;
}
s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* pNodeCreateReq) {
return 2;
}
s32 fpcNdRq_phase_IsDeleted(node_create_request* pNodeCreateReq) {
return fpcDt_IsComplete() == 0 ? cPhs_ZERO_e : 2;
}
s32 fpcNdRq_phase_Delete(node_create_request* pNodeCreateReq) {
if (pNodeCreateReq->mNodeProc.mpNodeProc != NULL) {
if (fpcDt_Delete(&pNodeCreateReq->mNodeProc.mpNodeProc->mBase) == 0) {
return cPhs_ZERO_e;
}
pNodeCreateReq->mNodeProc.mpNodeProc = NULL;
}
return 2;
}
s32 fpcNdRq_DoPhase(node_create_request* pNodeCreateReq) {
s32 result =
cPhs_Handler(&pNodeCreateReq->mReqPhsProc, pNodeCreateReq->mpPhsHandler, pNodeCreateReq);
if (result == 0x2) {
return fpcNdRq_DoPhase(pNodeCreateReq);
}
return result;
}
s32 fpcNdRq_Execute(node_create_request* pNodeCreateReq) {
s32 result = fpcNdRq_DoPhase(pNodeCreateReq);
switch (result) {
case 0:
case 1:
return 0;
case 4:
return 2;
case 5:
case 3:
return 3;
default:
return result;
}
}
s32 fpcNdRq_Delete(node_create_request* pNodeCreateReq) {
fpcNdRq_RequestQTo(pNodeCreateReq);
if (pNodeCreateReq->mpNodeCrReqMthCls != NULL &&
pNodeCreateReq->mpNodeCrReqMthCls->mpUnkFunc != NULL &&
fpcMtd_Method(pNodeCreateReq->mpNodeCrReqMthCls->mpUnkFunc, pNodeCreateReq) == 0) {
return 0;
}
cMl_NS_free(pNodeCreateReq);
return 1;
}
s32 fpcNdRq_Cancel(node_create_request* pNodeCreateReq) {
if (pNodeCreateReq->mpNodeCrReqMthCls != NULL &&
fpcMtd_Method(pNodeCreateReq->mpNodeCrReqMthCls->mpCancelFunc, pNodeCreateReq) == 0) {
return 0;
}
return fpcNdRq_Delete(pNodeCreateReq);
}
#define NODE_GET_NEXT(pNode) (pNode ? pNode->mpNextNode : NULL)
s32 fpcNdRq_Handler(void) {
node_class* currentNode = lbl_803A3A38.mpHead;
while (currentNode != NULL) {
node_create_request* req = ((request_node_class*)currentNode)->mNodeCrReq;
switch (req->mpNodeCrReqMthCls->mpExecuteFunc(req)) {
case 3:
case 5:
currentNode = NODE_GET_NEXT(currentNode);
if (fpcNdRq_Cancel(req) == 0) {
return 0;
}
break;
case 4:
currentNode = NODE_GET_NEXT(currentNode);
if (fpcNdRq_Delete(req) == 0) {
return 0;
}
break;
default:
currentNode = NODE_GET_NEXT(currentNode);
break;
}
}
return 1;
}
s32 fpcNdRq_IsPossibleTarget(process_node_class* pProcNode) {
s32 bsPcId = pProcNode->mBase.mBsPcId;
request_node_class* currentNode;
node_create_request* currentNdCr;
currentNode = (request_node_class*)lbl_803A3A38.mpHead;
while (currentNode != NULL) {
currentNdCr = currentNode->mNodeCrReq;
if ((currentNdCr->mParameter == 2 || currentNdCr->mParameter == 4 ||
currentNdCr->mParameter == 1) &&
currentNdCr->mNodeProc.mProcId == bsPcId) {
return 0;
}
currentNode = (request_node_class*)NODE_GET_NEXT((&currentNode->mBase));
}
return 1;
}
s32 fpcNdRq_IsIng(process_node_class* pProcNode) {
request_node_class* currentNode;
node_create_request* currentNodeReq;
s32 bsPcId = pProcNode->mBase.mBsPcId;
currentNode = (request_node_class*)lbl_803A3A38.mpHead;
while (currentNode != NULL) {
currentNodeReq = currentNode->mNodeCrReq;
if (currentNodeReq->mCreatingID == bsPcId) {
return 1;
}
currentNode = (request_node_class*)NODE_GET_NEXT((&currentNode->mBase));
}
return 0;
}
node_create_request* fpcNdRq_Create(s32 pRequestSize) {
node_create_request* req = (node_create_request*)cMl_NS_memalignB(-4, pRequestSize);
if (req != NULL) {
if (lbl_80450D4C == 0) {
lbl_80450D48 = 0;
lbl_80450D4C = 1;
}
sBs_ClearArea(req, pRequestSize);
*req = lbl_803A3A44;
// req->mCreateTag = lbl_803A3A44.mCreateTag;
// req->mProcMthCls = lbl_803A3A44.mProcMthCls;
// req->mReqPhsProc = lbl_803A3A44.mReqPhsProc;
// req->mpPhsHandler = lbl_803A3A44.mpPhsHandler;
// req->mpNodeCrReqMthCls = lbl_803A3A44.mpNodeCrReqMthCls;
// req->mParameter = lbl_803A3A44.mParameter;
// req->mRequestId = lbl_803A3A44.mRequestId;
// req->mNodeProc = lbl_803A3A44.mNodeProc;
// req->mpLayerClass = lbl_803A3A44.mpLayerClass;
// req->mCreatingID = lbl_803A3A44.mCreatingID;
// req->mProcName = lbl_803A3A44.mProcName;
// req->mpUserData = lbl_803A3A44.mpUserData;
// req->unk_0x60 = lbl_803A3A44.unk_0x60;
cTg_Create(&req->mCreateTag, req);
fpcMtdTg_Init(&req->mProcMthCls, (process_method_tag_func)fpcNdRq_Cancel, req);
req->mRequestId = lbl_80450D48++;
}
return req;
}
node_create_request* fpcNdRq_ChangeNode(u32 pRequestSize, process_node_class* pProcNode,
s16 param_3, void* param_4) {
if (fpcNdRq_IsPossibleTarget(pProcNode) == 1 && fpcNdRq_IsIng(pProcNode) == 0) {
node_create_request* req = fpcNdRq_Create(pRequestSize);
if (req != NULL) {
req->mpPhsHandler = lbl_803A3AA8;
req->mNodeProc.mpNodeProc = pProcNode;
req->mNodeProc.mProcId = pProcNode->mBase.mBsPcId;
req->mpLayerClass = pProcNode->mBase.mLyTg.mpLayer;
req->mProcName = param_3;
req->mpUserData = param_4;
}
return req;
} else {
return NULL;
}
}
node_create_request* fpcNdRq_DeleteNode(u32 pRequestSize, process_node_class* pProcNode) {
if (fpcNdRq_IsPossibleTarget(pProcNode) == 1 && fpcNdRq_IsIng(pProcNode) == 0) {
node_create_request* req = fpcNdRq_Create(pRequestSize);
if (req != NULL) {
req->mpPhsHandler = lbl_803A3AC0;
req->mNodeProc.mpNodeProc = pProcNode;
req->mNodeProc.mProcId = pProcNode->mBase.mBsPcId;
req->mpLayerClass = pProcNode->mBase.mLyTg.mpLayer;
}
return req;
} else {
return NULL;
}
}
node_create_request* fpcNdRq_CreateNode(u32 pRequestSize, s16 param_2, void* param_3) {
layer_class* layer = fpcLy_CurrentLayer();
if (layer->mLayerID != 0 && fpcNdRq_IsPossibleTarget(layer->mpPcNode) == 0) {
return NULL;
} else {
node_create_request* req = fpcNdRq_Create(pRequestSize);
if (req != NULL) {
req->mpPhsHandler = lbl_803A3AD0;
if (layer->mLayerID != 0) {
req->mNodeProc.mpNodeProc = layer->mpPcNode;
req->mNodeProc.mProcId = layer->mpPcNode->mBase.mBsPcId;
}
req->mpLayerClass = layer;
req->mProcName = param_2;
req->mpUserData = param_3;
}
return req;
}
}
node_create_request*
fpcNdRq_Request(u32 param_1, s32 param_2, process_node_class* param_3, s16 param_4, void* param_5,
node_create_request_method_class* pNodeCreateRequestMethodClass) {
node_create_request* req;
switch (param_2) {
case 0:
req = fpcNdRq_CreateNode(param_1, param_4, param_5);
break;
case 1:
req = fpcNdRq_DeleteNode(param_1, param_3);
break;
case 2:
req = fpcNdRq_ChangeNode(param_1, param_3, param_4, param_5);
break;
case 4:
break;
}
if (req != NULL) {
req->mParameter = param_2;
req->mpNodeCrReqMthCls = pNodeCreateRequestMethodClass;
fpcNdRq_ToRequestQ(req);
}
return req;
}
s32 fpcNdRq_ReChangeNode(u32 pRequestId, s16 param_2, void* param_3) {
request_node_class* currentNode;
node_create_request* found;
currentNode = (request_node_class*)lbl_803A3A38.mpHead;
while (currentNode != NULL) {
found = currentNode->mNodeCrReq;
if (found->mParameter == 2 && found->mRequestId == pRequestId) {
if (found->mCreatingID == -2) {
found->mProcName = param_2;
found->mpUserData = param_3;
return 1;
}
return 0;
}
currentNode = (request_node_class*)NODE_GET_NEXT((&currentNode->mBase));
}
return 0;
}
s32 fpcNdRq_ReRequest(u32 pRequestId, s16 param_2, void* param_3) {
return fpcNdRq_ReChangeNode(pRequestId, param_2, param_3);
}
}
src/f/f_pc/f_pc_pause.cpp
+11 -13
View File
@@ -4,25 +4,25 @@
#include "f/f_pc/f_pc_layer_iter.h"
#include "f/f_pc/f_pc_node.h"
// f_pc_node::g_fpcNd_type
extern s32 lbl_80450D40;
extern "C" {
// f_pc_node::g_fpcNd_type
extern int lbl_80450D40;
#if NON_MATCHING
bool fpcPause_IsEnable(void* pProcess, u8 flag) {
#ifdef NON_MATCHING
s32 fpcPause_IsEnable(void* pProcess, u8 flag) {
base_process_class* pProc = (base_process_class*)pProcess;
// extra addic/subfe?
return (pProc->mPauseFlag & flag) == flag;
}
#else
asm bool fpcPause_IsEnable(void* pProcess, u8 flag) {
asm s32 fpcPause_IsEnable(void* pProcess, u8 flag) {
nofralloc
#include "f/f_pc/f_pc_pause/asm/func_80023844.s"
#include "f/f_pc/asm/80023844.s"
}
#endif
int fpcPause_Enable(void* pProcess, u8 flag) {
s32 fpcPause_Enable(void* pProcess, u8 flag) {
base_process_class* pProc = (base_process_class*)pProcess;
pProc->mPauseFlag |= flag;
@@ -33,15 +33,13 @@ int fpcPause_Enable(void* pProcess, u8 flag) {
return 1;
}
// According to symbols, they used u8 instead of u32, but I can't get a match with u8 here. This is
// the best I got...
int fpcPause_Disable(void* pProcess, u32 flag) {
s32 fpcPause_Disable(void* pProcess, u8 flag) {
base_process_class* pProc = (base_process_class*)pProcess;
pProc->mPauseFlag &= (0xFF - flag) & 0xFF;
if (fpcBs_Is_JustOfType(lbl_80450D40, pProc->mSubType)) {
process_node_class* pNode = (process_node_class*)pProc;
fpcLyIt_OnlyHere(&pNode->mLayer, (cNdIt_MethodFunc)fpcPause_Disable, (void*)(flag & 0xFF));
fpcLyIt_OnlyHere(&pNode->mLayer, (cNdIt_MethodFunc)fpcPause_Disable, (void*)flag);
}
return 1;
@@ -51,4 +49,4 @@ void fpcPause_Init(void* pProcess) {
base_process_class* pProc = (base_process_class*)pProcess;
pProc->mPauseFlag = 0;
}
}
}
src/f/f_pc/f_pc_priority.cpp
+38 -28
View File
@@ -4,33 +4,33 @@
#include "f/f_pc/f_pc_layer.h"
#include "f/f_pc/f_pc_layer_tag.h"
extern "C" {
// f_pc_priority::crear$2186
extern process_priority_queue_info lbl_804505E8;
// f_pc_priority::l_fpcPi_Queue
extern node_list_class lbl_803F4E58;
int fpcPi_IsInQueue(process_priority_class* pPi) {
return cTg_IsUse(pPi);
extern "C" {
s32 fpcPi_IsInQueue(process_priority_class* pPi) {
return cTg_IsUse(&pPi->mBase);
}
int fpcPi_QueueTo(process_priority_class* pPi) {
cTg_SingleCut(pPi);
s32 fpcPi_QueueTo(process_priority_class* pPi) {
cTg_SingleCut(&pPi->mBase);
fpcLy_CancelQTo(&pPi->mMtdTag);
return 1;
}
int fpcPi_ToQueue(process_priority_class* pPi) {
s32 fpcPi_ToQueue(process_priority_class* pPi) {
u32 layer = pPi->mInfoQ.mLayer;
if (cTg_Addition(&lbl_803F4E58, pPi)) {
if (cTg_Addition(&lbl_803F4E58, &pPi->mBase)) {
if (layer != 0xFFFFFFFD) {
layer_class* pLayer = fpcLy_Layer(layer);
if (!fpcLy_ToCancelQ(pLayer, &pPi->mMtdTag)) {
cTg_SingleCut(pPi);
cTg_SingleCut(&pPi->mBase);
return 0;
}
}
@@ -45,7 +45,7 @@ process_priority_class* fpcPi_GetFromQueue(void) {
process_priority_class* pPi = (process_priority_class*)cTg_GetFirst(&lbl_803F4E58);
if (pPi != NULL) {
base_process_class* pProc = (base_process_class*)pPi->mpTagData;
base_process_class* pProc = (base_process_class*)pPi->mBase.mpTagData;
process_priority_class* pProcPi = &pProc->mPi;
fpcLy_CancelQTo(&pProcPi->mMtdTag);
return pProcPi;
@@ -54,23 +54,24 @@ process_priority_class* fpcPi_GetFromQueue(void) {
return NULL;
}
int fpcPi_Delete(process_priority_class* pPi) {
s32 fpcPi_Delete(process_priority_class* pPi) {
fpcPi_QueueTo(pPi);
pPi->mInfoQ = lbl_804505E8;
pPi->mInfoQ.mLayer = lbl_804505E8.mLayer;
pPi->mInfoQ.mListID = lbl_804505E8.mListID;
pPi->mInfoQ.mListPrio = lbl_804505E8.mListPrio;
return 1;
}
int fpcPi_IsNormal(unsigned int layer, unsigned short listID, unsigned short priority) {
s32 fpcPi_IsNormal(u32 layer, u16 listID, u16 priority) {
if ((layer < 0xFFFFFFFE) && (listID < 0xFFFE) && (priority < 0xFFFE))
return 1;
return 0;
}
int fpcPi_Change(process_priority_class* pPi, unsigned int layer, unsigned short listID,
unsigned short priority) {
base_process_class* pProc = (base_process_class*)pPi->mpTagData;
int changed = 0;
s32 fpcPi_Change(process_priority_class* pPi, u32 layer, u16 listID, u16 priority) {
base_process_class* pProc = (base_process_class*)pPi->mBase.mpTagData;
BOOL changed = 0;
if (pProc->mInitState == 3)
return 0;
@@ -78,7 +79,9 @@ int fpcPi_Change(process_priority_class* pPi, unsigned int layer, unsigned short
if (!fpcPi_IsNormal(layer, listID, priority))
return 0;
pPi->mInfoQ = pPi->mInfoCurr;
pPi->mInfoQ.mLayer = pPi->mInfoCurr.mLayer;
pPi->mInfoQ.mListID = pPi->mInfoCurr.mListID;
pPi->mInfoQ.mListPrio = pPi->mInfoCurr.mListPrio;
if (layer != 0xFFFFFFFD && pPi->mInfoCurr.mLayer != layer) {
pPi->mInfoQ.mLayer = layer;
@@ -96,7 +99,9 @@ int fpcPi_Change(process_priority_class* pPi, unsigned int layer, unsigned short
}
if (pProc->mInitState == 0 || pProc->mInitState == 1) {
pPi->mInfoCurr = pPi->mInfoQ;
pPi->mInfoCurr.mLayer = pPi->mInfoQ.mLayer;
pPi->mInfoCurr.mListID = pPi->mInfoQ.mListID;
pPi->mInfoCurr.mListPrio = pPi->mInfoQ.mListPrio;
return 1;
}
@@ -106,15 +111,18 @@ int fpcPi_Change(process_priority_class* pPi, unsigned int layer, unsigned short
return 0;
}
int fpcPi_Handler(void) {
while (process_priority_class* pPi = fpcPi_GetFromQueue()) {
base_process_class* pProc = (base_process_class*)pPi->mpTagData;
s32 fpcPi_Handler(void) {
process_priority_class* pPi;
while (pPi = fpcPi_GetFromQueue()) {
base_process_class* pProc = (base_process_class*)pPi->mBase.mpTagData;
layer_management_tag_class* pLayerTag = &pProc->mLyTg;
line_tag* pLineTag = &pProc->mLnTg;
if (fpcLyTg_Move(pLayerTag, pPi->mInfoQ.mLayer, pPi->mInfoQ.mListID,
pPi->mInfoQ.mListPrio) == 1) {
fpcLnTg_Move(pLineTag, pPi->mInfoCurr.mListID);
pPi->mInfoCurr = pPi->mInfoQ;
pPi->mInfoCurr.mLayer = pPi->mInfoQ.mLayer;
pPi->mInfoCurr.mListID = pPi->mInfoQ.mListID;
pPi->mInfoCurr.mListPrio = pPi->mInfoQ.mListPrio;
} else {
return 0;
}
@@ -123,17 +131,19 @@ int fpcPi_Handler(void) {
return 1;
}
int fpcPi_Init(process_priority_class* pPi, void* pUserData, unsigned int layer,
unsigned short listID, unsigned short priority) {
s32 fpcPi_Init(process_priority_class* pPi, void* pUserData, u32 layer, u16 listID, u16 priority) {
if (!fpcPi_IsNormal(layer, listID, priority))
return 0;
pPi->mInfoQ.mLayer = layer;
pPi->mInfoQ.mListID = listID;
pPi->mInfoQ.mListPrio = priority;
pPi->mInfoCurr = pPi->mInfoQ;
cTg_Create(pPi, pUserData);
pPi->mInfoCurr.mLayer = pPi->mInfoQ.mLayer;
pPi->mInfoCurr.mListID = pPi->mInfoQ.mListID;
pPi->mInfoCurr.mListPrio = pPi->mInfoQ.mListPrio;
cTg_Create(&pPi->mBase, pUserData);
fpcMtdTg_Init(&pPi->mMtdTag, (process_method_tag_func)fpcPi_Delete, pPi);
return 1;
}
};
}
src/f/f_pc/f_pc_profile.cpp
+3 -3
View File
@@ -2,11 +2,11 @@
#include "f/f_pc/f_pc_profile.h"
// g_fpcPf_ProfileList_p
extern void** lbl_80450D50;
extern process_profile_definition** lbl_80450D50;
extern "C" {
void* fpcPf_Get(s16 profileID) {
process_profile_definition* fpcPf_Get(s16 profileID) {
return lbl_80450D50[profileID];
}
};
}
src/f/f_pc/f_pc_searcher.cpp
+3 -3
View File
@@ -5,16 +5,16 @@
extern "C" {
void* fpcSch_JudgeForPName(base_process_class* pProc, void* pUserData) {
short pname = *(short*)pUserData;
s16 pname = *(s16*)pUserData;
if (pProc->mProcName == pname)
return pProc;
return NULL;
}
void* fpcSch_JudgeByID(base_process_class* pProc, void* pUserData) {
int id = *(int*)pUserData;
s32 id = *(s32*)pUserData;
if (pProc->mBsPcId == id)
return pProc;
return NULL;
}
};
}
src/f/f_pc/f_pc_stdcreate_req.cpp
+113 -1
View File
@@ -1 +1,113 @@
// ok
#include "f/f_pc/f_pc_stdcreate_req.h"
#include "dolphin/types.h"
// #include "f/f_pc/f_pc_load.h"
#include "f/f_pc/f_pc_base.h"
#include "f/f_pc/f_pc_node.h"
// f_pc_node::g_fpcNd_type
extern s32 lbl_80450D40;
// f_pc_stdcreate_req::submethod$2261
extern create_request_method_class lbl_803A3AF0;
// f_pc_stdcreate_req::method$2262
extern cPhs__Handler lbl_803A3AFC[7];
extern "C" {
extern s32 fpcLd_Load(s16);
extern s32 fpcLd_Free(s16);
s32 fpcSCtRq_phase_Load(standard_create_request_class* pStdCreateReq) {
switch (fpcLd_Load(pStdCreateReq->mLoadID)) {
case 0:
return cPhs_ZERO_e;
case 4:
return 2;
case 5:
default:
return cPhs_ERROR_e;
}
}
s32 fpcSCtRq_phase_CreateProcess(standard_create_request_class* pStdCreateReq) {
fpcLy_SetCurrentLayer(pStdCreateReq->mBase.mpLayer);
pStdCreateReq->mBase.mpRes =
fpcBs_Create(pStdCreateReq->mLoadID, pStdCreateReq->mBase.mBsPcId, pStdCreateReq->unk_0x54);
if (pStdCreateReq->mBase.mpRes == NULL) {
fpcLd_Free(pStdCreateReq->mLoadID);
return cPhs_ERROR_e;
} else {
pStdCreateReq->mBase.mpRes->mpCtRq = (struct create_request*)pStdCreateReq;
return 2;
}
}
s32 fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* pStdCreateReq) {
fpcLy_SetCurrentLayer(pStdCreateReq->mBase.mpLayer);
return fpcBs_SubCreate(pStdCreateReq->mBase.mpRes);
}
s32 fpcSCtRq_phase_IsComplete(standard_create_request_class* pStdCreateReq) {
process_node_class* procNode = (process_node_class*)pStdCreateReq->mBase.mpRes;
if (fpcBs_Is_JustOfType(lbl_80450D40, procNode->mBase.mSubType) == 1) {
if (fpcLy_IsCreatingMesg(&procNode->mLayer) == 1) {
return cPhs_ZERO_e;
}
}
return 2;
}
s32 fpcSCtRq_phase_PostMethod(standard_create_request_class* pStdCreateReq) {
if (pStdCreateReq->unk_0x58 != NULL &&
pStdCreateReq->unk_0x58(pStdCreateReq->mBase.mpRes, pStdCreateReq->unk_0x5C) == 0) {
return cPhs_ZERO_e;
} else {
return 2;
}
}
s32 fpcSCtRq_phase_Done(standard_create_request_class* pStdCreateReq) {
return 2;
}
s32 fpcSCtRq_Handler(standard_create_request_class* pStdCreateReq) {
s32 result = cPhs_Do(&pStdCreateReq->unk_0x48, pStdCreateReq);
switch (result) {
case 2:
return fpcSCtRq_Handler(pStdCreateReq);
case 4:
return 4;
case 1:
case 5:
default:
return result;
}
}
s32 fpcSCtRq_Delete(standard_create_request_class* pStdCreateReq) {
return 1;
}
s32 fpcSCtRq_Cancel(standard_create_request_class* pStdCreateReq) {
return 1;
}
s32 fpcSCtRq_Request(layer_class* param_1, s16 param_2, stdCreateFunc param_3, void* param_4,
void* param_5) {
if (param_2 >= 0x7FFF) {
return -1;
} else {
standard_create_request_class* request =
(standard_create_request_class*)fpcCtRq_Create(param_1, 0x60, &lbl_803A3AF0);
if (request == NULL) {
return -1;
} else {
cPhs_Set(&request->unk_0x48, lbl_803A3AFC);
request->mLoadID = param_2;
request->unk_0x58 = param_3;
request->unk_0x5C = param_4;
request->unk_0x54 = param_5;
return request->mBase.mBsPcId;
}
}
}
}
src/m_Do/m_Do_main.cpp
+1
View File
@@ -2,6 +2,7 @@
#include "d/d_com/d_com_inf_game/d_com_inf_game.h"
#include "dvd/dvd.h"
#include "global.h"
#include "m_Do/m_Do_controller_pad/m_Do_controller_pad.h"
#include "m_Do/m_Do_reset/m_Do_reset.h"
void version_check(void) {