diff --git a/include/SSystem/SStandard/s_basic.h b/include/SSystem/SStandard/s_basic.h index fe5fd534b9..3fea9ad699 100644 --- a/include/SSystem/SStandard/s_basic.h +++ b/include/SSystem/SStandard/s_basic.h @@ -3,4 +3,7 @@ #include "dolphin/types.h" +void sBs_FillArea_s(void* pPtr, u32 pNumBytes, s16 pValue); +void sBs_ClearArea(void* pPtr, u32 pNumBytes); + #endif /* S_BASIC_H */ diff --git a/include/f_pc/f_pc_base.h b/include/f_pc/f_pc_base.h index b38e3a8625..baed3a5d7a 100644 --- a/include/f_pc/f_pc_base.h +++ b/include/f_pc/f_pc_base.h @@ -1,6 +1,53 @@ -#ifndef F_PC_F_PC_BASE_H -#define F_PC_F_PC_BASE_H +#ifndef F_PC_BASE_H_ +#define F_PC_BASE_H_ + +#include "SSystem/SComponent/c_tag.h" #include "dolphin/types.h" +// #include "f/f_pc/f_pc_method.h" +#include "f_pc/f_pc_delete_tag.h" +#include "f_pc/f_pc_layer_tag.h" +#include "f_pc/f_pc_line_tag.h" +#include "f_pc/f_pc_priority.h" +#include "f_pc/f_pc_profile.h" -#endif /* F_PC_F_PC_BASE_H */ +struct create_request; +struct profile_method_class; + +typedef struct base_process_class { + /* 0x00 */ u32 mBsType; + /* 0x04 */ u32 mBsPcId; + /* 0x08 */ s16 mProcName; + /* 0x0A */ s8 mUnk0; + /* 0x0B */ u8 mPauseFlag; + /* 0x0C */ s8 mInitState; + /* 0x0D */ u8 mUnk2; + /* 0x0E */ s16 mBsTypeId; + /* 0x10 */ process_profile_definition* mpProf; + /* 0x14 */ struct create_request* mpCtRq; + /* 0x18 */ layer_management_tag_class mLyTg; + /* 0x34 */ line_tag mLnTg; + /* 0x4C */ delete_tag_class mDtTg; + /* 0x68 */ process_priority_class mPi; + /* 0xA8 */ process_method_class* mpPcMtd; + /* 0xAC */ void* mpUserData; + /* 0xB0 */ u32 mParameters; + /* 0xB4 */ u32 mSubType; +} base_process_class; // Size: 0xB8 + +BOOL fpcBs_Is_JustOfType(int pType1, int pType2); +s32 fpcBs_MakeOfType(int* pType); +s32 fpcBs_MakeOfId(void); +s32 fpcBs_Execute(base_process_class* pProc); +void fpcBs_DeleteAppend(base_process_class* pProc); +s32 fpcBs_IsDelete(base_process_class* pProc); +s32 fpcBs_Delete(base_process_class* pProc); +base_process_class* fpcBs_Create(s16 pProcTypeID, unsigned int pProcID, void* pData); +s32 fpcBs_SubCreate(base_process_class* pProc); + +extern "C" { +void fpcBs_MakeOfType__FPi(void); +void fpcBs_Is_JustOfType__Fii(void); +} + +#endif diff --git a/include/f_pc/f_pc_create_iter.h b/include/f_pc/f_pc_create_iter.h index f01fd53db0..05b4cc3e40 100644 --- a/include/f_pc/f_pc_create_iter.h +++ b/include/f_pc/f_pc_create_iter.h @@ -1,6 +1,34 @@ -#ifndef F_PC_F_PC_CREATE_ITER_H -#define F_PC_F_PC_CREATE_ITER_H +#ifndef F_PC_CREATE_ITER_H_ +#define F_PC_CREATE_ITER_H_ + +#include "SSystem/SComponent/c_list_iter.h" +#include "SSystem/SComponent/c_tag_iter.h" +#include "f_pc/f_pc_create_tag.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_CREATE_ITER_H */ +typedef int (*fpcCtIt_MethodFunc)(void*, void*); +typedef void* (*fpcCtIt_JudgeFunc)(void*, void*); + +typedef struct node_method_data { + fpcCtIt_MethodFunc mFunc; + void* mpUserData; +} node_method_data; + +typedef struct node_judge_data { + fpcCtIt_JudgeFunc mFunc; + void* mpUserData; +} node_judge_data; + +typedef struct fpcCtIt_jilprm_c { + u32 mLayerID; + fpcCtIt_JudgeFunc mFunc; + void* mpUserData; +} fpcCtIt_jilprm_c; + +s32 fpcCtIt_Method(fpcCtIt_MethodFunc pJudge, void* pUserData); +void* fpcCtIt_Judge(fpcCtIt_JudgeFunc pJudge, void* pUserData); +void* fpcCtIt_filter_JudgeInLayer(create_tag*, fpcCtIt_jilprm_c*); +void* fpcCtIt_JudgeInLayer(unsigned int pUnk0, fpcCtIt_JudgeFunc pFunc, void* pUserData); + +#endif diff --git a/include/f_pc/f_pc_create_req.h b/include/f_pc/f_pc_create_req.h index 39e4956c87..83763358ec 100644 --- a/include/f_pc/f_pc_create_req.h +++ b/include/f_pc/f_pc_create_req.h @@ -1,6 +1,44 @@ -#ifndef F_PC_F_PC_CREATE_REQ_H -#define F_PC_F_PC_CREATE_REQ_H +#ifndef F_PC_CREATE_REQ_H_ +#define F_PC_CREATE_REQ_H_ + +#include "SSystem/SComponent/c_phase.h" +#include "SSystem/SComponent/c_tag.h" +#include "f_pc/f_pc_create_tag.h" +#include "f_pc/f_pc_layer.h" +#include "f_pc/f_pc_method.h" +#include "f_pc/f_pc_method_tag.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_CREATE_REQ_H */ +struct base_process_class; + +typedef struct create_request_method_class { + cPhs__Handler mpHandler; + process_method_func mpCancel; + process_method_func mpDelete; +} create_request_method_class; + +typedef struct create_request { + create_tag mBase; + s8 mbIsCreating; + s8 mbIsCancelling; + process_method_tag_class mMtdTg; + create_request_method_class* mpCtRqMtd; + void* mpUnk1; + s32 mBsPcId; + struct base_process_class* mpRes; + layer_class* mpLayer; +} create_request; // Size: 0x48 + +BOOL fpcCtRq_isCreatingByID(create_tag* pTag, unsigned int* pId); +BOOL fpcCtRq_IsCreatingByID(unsigned int id); +void fpcCtRq_CreateQTo(create_request* pReq); +void fpcCtRq_ToCreateQ(create_request* pReq); +BOOL fpcCtRq_Delete(create_request* pReq); +BOOL fpcCtRq_Cancel(create_request* pReq); +s32 fpcCtRq_IsDoing(create_request* pReq); +void fpcCtRq_Handler(void); +create_request* fpcCtRq_Create(layer_class* pLayer, u32 size, + create_request_method_class* pCtRqMtd); + +#endif diff --git a/include/f_pc/f_pc_create_tag.h b/include/f_pc/f_pc_create_tag.h index 8f3df92c1c..faa6d10249 100644 --- a/include/f_pc/f_pc_create_tag.h +++ b/include/f_pc/f_pc_create_tag.h @@ -1,6 +1,18 @@ -#ifndef F_PC_F_PC_CREATE_TAG_H -#define F_PC_F_PC_CREATE_TAG_H +#ifndef F_PC_CREATE_TAG_H_ +#define F_PC_CREATE_TAG_H_ + +#include "SSystem/SComponent/c_tag.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_CREATE_TAG_H */ +typedef struct create_tag { + create_tag_class mBase; +} create_tag; + +void fpcCtTg_ToCreateQ(create_tag* pTag); +void fpcCtTg_CreateQTo(create_tag* pTag); +s32 fpcCtTg_Init(create_tag* pTag, void* pUserData); + +extern node_list_class g_fpcCtTg_Queue; + +#endif diff --git a/include/f_pc/f_pc_creator.h b/include/f_pc/f_pc_creator.h index 86cb3ce434..ebae2011c4 100644 --- a/include/f_pc/f_pc_creator.h +++ b/include/f_pc/f_pc_creator.h @@ -1,6 +1,14 @@ -#ifndef F_PC_F_PC_CREATOR_H -#define F_PC_F_PC_CREATOR_H + +#ifndef F_PC_CREATOR_H_ +#define F_PC_CREATOR_H_ #include "dolphin/types.h" -#endif /* F_PC_F_PC_CREATOR_H */ +struct base_process_class; + +BOOL fpcCt_IsCreatingByID(unsigned int id); +s32 fpcCt_IsDoing(struct base_process_class* pProc); +BOOL fpcCt_Abort(struct base_process_class* pProc); +void fpcCt_Handler(void); + +#endif diff --git a/include/f_pc/f_pc_delete_tag.h b/include/f_pc/f_pc_delete_tag.h index 445012d194..d54e609c3c 100644 --- a/include/f_pc/f_pc_delete_tag.h +++ b/include/f_pc/f_pc_delete_tag.h @@ -1,6 +1,25 @@ -#ifndef F_PC_F_PC_DELETE_TAG_H -#define F_PC_F_PC_DELETE_TAG_H +#ifndef F_PC_DELETE_TAG_H_ +#define F_PC_DELETE_TAG_H_ + +#include "SSystem/SComponent/c_tag.h" +#include "f_pc/f_pc_layer.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_DELETE_TAG_H */ +typedef int (*delete_tag_func)(void*); + +typedef struct delete_tag_class { + create_tag_class mBase; + layer_class* mpLayer; + s16 mTimer; +} delete_tag_class; + +BOOL fpcDtTg_IsEmpty(void); +void fpcDtTg_ToDeleteQ(delete_tag_class* pTag); +void fpcDtTg_DeleteQTo(delete_tag_class* pTag); +s32 fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc); +s32 fpcDtTg_Init(delete_tag_class* pTag, void* pUserData); + +extern node_list_class g_fpcDtTg_Queue; + +#endif diff --git a/include/f_pc/f_pc_deletor.h b/include/f_pc/f_pc_deletor.h index 0b1dd35efd..79185d966f 100644 --- a/include/f_pc/f_pc_deletor.h +++ b/include/f_pc/f_pc_deletor.h @@ -1,6 +1,15 @@ -#ifndef F_PC_F_PC_DELETOR_H -#define F_PC_F_PC_DELETOR_H -#include "dolphin/types.h" +#ifndef F_PC_DELETOR_H_ +#define F_PC_DELETOR_H_ -#endif /* F_PC_F_PC_DELETOR_H */ +#include "f_pc/f_pc_base.h" + +struct base_process_class; + +BOOL fpcDt_IsComplete(void); +s32 fpcDt_ToDeleteQ(base_process_class* pProc); +s32 fpcDt_ToQueue(base_process_class* pProc); +void fpcDt_Handler(void); +s32 fpcDt_Delete(void* pProc); + +#endif diff --git a/include/f_pc/f_pc_draw.h b/include/f_pc/f_pc_draw.h index 854766878c..50529291b0 100644 --- a/include/f_pc/f_pc_draw.h +++ b/include/f_pc/f_pc_draw.h @@ -1,6 +1,14 @@ -#ifndef F_PC_F_PC_DRAW_H -#define F_PC_F_PC_DRAW_H +#ifndef F_PC_DRAW_H_ +#define F_PC_DRAW_H_ +#include "SSystem/SComponent/c_node_iter.h" +#include "f_pc/f_pc_base.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_DRAW_H */ +typedef int (*fpcDw_HandlerFunc)(void*, void*); +typedef int (*fpcDw_HandlerFuncFunc)(fpcDw_HandlerFunc); + +s32 fpcDw_Execute(base_process_class* pProc); +s32 fpcDw_Handler(fpcDw_HandlerFuncFunc param_1, fpcDw_HandlerFunc param_2); + +#endif \ No newline at end of file diff --git a/include/f_pc/f_pc_draw_priority.h b/include/f_pc/f_pc_draw_priority.h index 0a43e0b759..6acd5cba2a 100644 --- a/include/f_pc/f_pc_draw_priority.h +++ b/include/f_pc/f_pc_draw_priority.h @@ -1,6 +1,15 @@ -#ifndef F_PC_F_PC_DRAW_PRIORITY_H -#define F_PC_F_PC_DRAW_PRIORITY_H + +#ifndef F_PC_DRAW_PRIORITY_H_ +#define F_PC_DRAW_PRIORITY_H_ #include "dolphin/types.h" -#endif /* F_PC_F_PC_DRAW_PRIORITY_H */ +typedef struct draw_priority_class { + s16 mPriority; +} draw_priority_class; + +s32 fpcDwPi_Get(const draw_priority_class* pDwPi); +void fpcDwPi_Set(draw_priority_class* pDwPi, s16 p); +void fpcDwPi_Init(draw_priority_class* pDwPi, s16 p); + +#endif diff --git a/include/f_pc/f_pc_executor.h b/include/f_pc/f_pc_executor.h index 94d378b847..eaf0a22751 100644 --- a/include/f_pc/f_pc_executor.h +++ b/include/f_pc/f_pc_executor.h @@ -1,6 +1,23 @@ -#ifndef F_PC_F_PC_EXECUTOR_H -#define F_PC_F_PC_EXECUTOR_H -#include "dolphin/types.h" +#ifndef F_PC_EXECUTOR_H_ +#define F_PC_EXECUTOR_H_ -#endif /* F_PC_F_PC_EXECUTOR_H */ +#include "SSystem/SComponent/c_node_iter.h" +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_layer_iter.h" +#include "f_pc/f_pc_line_iter.h" + +base_process_class* fpcEx_Search(fpcLyIt_JudgeFunc pFunc, void* pUserData); +base_process_class* fpcEx_SearchByID(unsigned int id); +BOOL fpcEx_IsExist(unsigned int id); +s32 fpcEx_ToLineQ(base_process_class* pProc); +s32 fpcEx_ExecuteQTo(base_process_class* pProc); +s32 fpcEx_Execute(base_process_class* pProc); +s32 fpcEx_ToExecuteQ(base_process_class* pProc); +void fpcEx_Handler(fpcLnIt_QueueFunc pFunc); + +extern "C" { +void fpcEx_IsExist__FUi(void); +} + +#endif diff --git a/include/f_pc/f_pc_fstcreate_req.h b/include/f_pc/f_pc_fstcreate_req.h index 89c4a73cdc..e41943f981 100644 --- a/include/f_pc/f_pc_fstcreate_req.h +++ b/include/f_pc/f_pc_fstcreate_req.h @@ -1,6 +1,23 @@ -#ifndef F_PC_F_PC_FSTCREATE_REQ_H -#define F_PC_F_PC_FSTCREATE_REQ_H +#ifndef F_PC_FSTCREATE_REQ_H_ +#define F_PC_FSTCREATE_REQ_H_ +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_create_req.h" +#include "f_pc/f_pc_layer.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_FSTCREATE_REQ_H */ +typedef int (*fstCreateFunc)(void*, void*); + +typedef struct fast_create_request { + /* 0x00 */ create_request mBase; + /* 0x48 */ fstCreateFunc mpFastCreateFunc; + /* 0x4C */ void* mpFastCreateData; +} fast_create_request; // Size: 0x50 + +s32 fpcFCtRq_Do(fast_create_request* pFstCreateReq); +s32 fpcFCtRq_Delete(fast_create_request*); +base_process_class* fpcFCtRq_Request(layer_class* pLayer, s16 pProcTypeID, + fstCreateFunc pFastCreateFunc, void* pFastCreateData, + void* pData); + +#endif \ No newline at end of file diff --git a/include/f_pc/f_pc_layer.h b/include/f_pc/f_pc_layer.h index 0e637ca9a9..4e9e1f793b 100644 --- a/include/f_pc/f_pc_layer.h +++ b/include/f_pc/f_pc_layer.h @@ -1,6 +1,53 @@ -#ifndef F_PC_F_PC_LAYER_H -#define F_PC_F_PC_LAYER_H +#ifndef F_PC_LAYER_H_ +#define F_PC_LAYER_H_ + +#include "SSystem/SComponent/c_node.h" +#include "SSystem/SComponent/c_tag.h" +#include "SSystem/SComponent/c_tree.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_LAYER_H */ +struct process_method_tag_class; +typedef struct process_node_class process_node_class; + +typedef struct layer_class { + node_class mNode; + u32 mLayerID; + node_lists_tree_class mNodeListTree; + process_node_class* mpPcNode; + node_list_class mCancelList; + struct { + s16 mCreatingCount; + s16 mDeletingCount; + } counts; +} layer_class; + +void fpcLy_SetCurrentLayer(layer_class* pLayer); +layer_class* fpcLy_CurrentLayer(void); +layer_class* fpcLy_RootLayer(void); +layer_class* fpcLy_Layer(unsigned int id); +layer_class* fpcLy_Search(unsigned int id); +void fpcLy_Regist(layer_class* pLayer); + +void fpcLy_CreatedMesg(layer_class* pLayer); +void fpcLy_CreatingMesg(layer_class* pLayer); +void fpcLy_DeletedMesg(layer_class* pLayer); +void fpcLy_DeletingMesg(layer_class* pLayer); +BOOL fpcLy_IsCreatingMesg(layer_class* pLayer); +BOOL fpcLy_IsDeletingMesg(layer_class* pLayer); + +s32 fpcLy_IntoQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag, int idx); +s32 fpcLy_ToQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag); +s32 fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag); + +void fpcLy_Cancel(layer_class* pLayer); +BOOL fpcLy_CancelMethod(struct process_method_tag_class* pLayer); + +void fpcLy_CancelQTo(struct process_method_tag_class* pMthd); +s32 fpcLy_ToCancelQ(layer_class* pLayer, struct process_method_tag_class* pMthd); + +void fpcLy_Create(layer_class* pLayer, void* pPcNode, node_list_class* pLists, int listNum); + +s32 fpcLy_Delete(layer_class* pLayer); + +#endif diff --git a/include/f_pc/f_pc_layer_iter.h b/include/f_pc/f_pc_layer_iter.h index fa4ea12838..49928636f4 100644 --- a/include/f_pc/f_pc_layer_iter.h +++ b/include/f_pc/f_pc_layer_iter.h @@ -1,6 +1,21 @@ -#ifndef F_PC_F_PC_LAYER_ITER_H -#define F_PC_F_PC_LAYER_ITER_H +#ifndef F_PC_LAYER_ITER_H_ +#define F_PC_LAYER_ITER_H_ +#include "SSystem/SComponent/c_node_iter.h" +#include "f_pc/f_pc_layer.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_LAYER_ITER_H */ +typedef struct layer_iter { + void* mpFunc; + void* mpUserData; +} layer_iter; + +typedef int (*fpcLyIt_OnlyHereFunc)(void*, void*); +typedef void* (*fpcLyIt_JudgeFunc)(void*, void*); + +s32 fpcLyIt_OnlyHere(layer_class* pLayer, fpcLyIt_OnlyHereFunc pFunc, void* pUserData); +s32 fpcLyIt_OnlyHereLY(layer_class* pLayer, fpcLyIt_OnlyHereFunc pFunc, void* pUserData); +void* fpcLyIt_Judge(layer_class* pLayer, fpcLyIt_JudgeFunc pFunc, void* pUserData); +void* fpcLyIt_AllJudge(fpcLyIt_JudgeFunc pFunc, void* pUserData); + +#endif diff --git a/include/f_pc/f_pc_layer_tag.h b/include/f_pc/f_pc_layer_tag.h index 753ab53782..c7e48e15ea 100644 --- a/include/f_pc/f_pc_layer_tag.h +++ b/include/f_pc/f_pc_layer_tag.h @@ -1,6 +1,22 @@ -#ifndef F_PC_F_PC_LAYER_TAG_H -#define F_PC_F_PC_LAYER_TAG_H +#ifndef F_PC_LAYER_TAG_H_ +#define F_PC_LAYER_TAG_H_ + +#include "SSystem/SComponent/c_tag.h" +#include "f_pc/f_pc_layer.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_LAYER_TAG_H */ +typedef struct layer_management_tag_class { + create_tag_class mCreateTag; + layer_class* mpLayer; + u16 mNodeListID; + u16 mNodeListIdx; +} layer_management_tag_class; + +s32 fpcLyTg_QueueTo(layer_management_tag_class* pTag); +s32 fpcLyTg_ToQueue(layer_management_tag_class* pTag, unsigned int layerID, u16 listID, + u16 listPrio); +s32 fpcLyTg_Move(layer_management_tag_class*, unsigned int, u16, u16); +s32 fpcLyTg_Init(layer_management_tag_class*, unsigned int, void*); + +#endif diff --git a/include/f_pc/f_pc_leaf.h b/include/f_pc/f_pc_leaf.h index a4aee744f7..1e954c4020 100644 --- a/include/f_pc/f_pc_leaf.h +++ b/include/f_pc/f_pc_leaf.h @@ -1,6 +1,41 @@ -#ifndef F_PC_F_PC_LEAF_H -#define F_PC_F_PC_LEAF_H +#ifndef F_PC_LEAF_H_ +#define F_PC_LEAF_H_ + +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_draw_priority.h" +#include "f_pc/f_pc_method.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_LEAF_H */ +typedef struct leafdraw_method_class { + /* 0x00 */ process_method_class mBase; + /* 0x10 */ process_method_func mpDrawFunc; +} leafdraw_method_class; + +typedef struct leafdraw_class { + /* 0x00 */ base_process_class mBase; + /* 0xB8 */ leafdraw_method_class* mpDrawMtd; + /* 0xBC */ s8 mbUnk0; + /* 0xBD */ u8 mbUnk1; + /* 0xBE */ draw_priority_class mDwPi; +} leafdraw_class; + +typedef struct leaf_process_profile_definition { + /* 0x00 */ process_profile_definition mBase; + /* 0x1C */ leafdraw_method_class* mLfDrwMth; + /* 0x20 */ s16 unk20; + /* 0x22 */ u8 unk22[2]; + /* 0x24 */ s32 unk24; +} leaf_process_profile_definition; + +s32 fpcLf_GetPriority(const leafdraw_class* pLeaf); +s32 fpcLf_DrawMethod(leafdraw_method_class* pMthd, void* pUserData); +s32 fpcLf_Draw(leafdraw_class* pMthd); +s32 fpcLf_Execute(leafdraw_class* pLeaf); +s32 fpcLf_IsDelete(leafdraw_class* pLeaf); +s32 fpcLf_Delete(leafdraw_class* pLeaf); +s32 fpcLf_Create(leafdraw_class* pLeaf); + +extern int g_fpcLf_type; + +#endif diff --git a/include/f_pc/f_pc_line.h b/include/f_pc/f_pc_line.h index af13476e24..82a45f3804 100644 --- a/include/f_pc/f_pc_line.h +++ b/include/f_pc/f_pc_line.h @@ -1,6 +1,10 @@ -#ifndef F_PC_F_PC_LINE_H -#define F_PC_F_PC_LINE_H +#ifndef F_PC_LINE_H_ +#define F_PC_LINE_H_ -#include "dolphin/types.h" +#include "SSystem/SComponent/c_tree.h" -#endif /* F_PC_F_PC_LINE_H */ +void fpcLn_Create(void); + +extern node_lists_tree_class g_fpcLn_Queue; + +#endif \ No newline at end of file diff --git a/include/f_pc/f_pc_line_iter.h b/include/f_pc/f_pc_line_iter.h index cf559386d7..4a63c1e5e5 100644 --- a/include/f_pc/f_pc_line_iter.h +++ b/include/f_pc/f_pc_line_iter.h @@ -1,6 +1,11 @@ -#ifndef F_PC_F_PC_LINE_ITER_H -#define F_PC_F_PC_LINE_ITER_H -#include "dolphin/types.h" +#ifndef F_PC_LINE_ITER_H_ +#define F_PC_LINE_ITER_H_ -#endif /* F_PC_F_PC_LINE_ITER_H */ +#include "SSystem/SComponent/c_node_iter.h" + +typedef int (*fpcLnIt_QueueFunc)(void*, void*); + +void fpcLnIt_Queue(fpcLnIt_QueueFunc pFunc); + +#endif diff --git a/include/f_pc/f_pc_line_tag.h b/include/f_pc/f_pc_line_tag.h index 6b9255a2d7..c5e3ae5f73 100644 --- a/include/f_pc/f_pc_line_tag.h +++ b/include/f_pc/f_pc_line_tag.h @@ -1,6 +1,18 @@ -#ifndef F_PC_F_PC_LINE_TAG_H -#define F_PC_F_PC_LINE_TAG_H +#ifndef F_PC_LINE_TAG_H_ +#define F_PC_LINE_TAG_H_ + +#include "SSystem/SComponent/c_tag.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_LINE_TAG_H */ +typedef struct line_tag { + create_tag_class mBase; + s32 mLineListID; +} line_tag; + +s32 fpcLnTg_Move(line_tag* pLineTag, int newLineListID); +void fpcLnTg_QueueTo(line_tag* pLineTag); +s32 fpcLnTg_ToQueue(line_tag* pLineTag, int lineListID); +void fpcLnTg_Init(line_tag* pLineTag, void* pData); + +#endif diff --git a/include/f_pc/f_pc_load.h b/include/f_pc/f_pc_load.h index f7abe97989..3fdbdf56a3 100644 --- a/include/f_pc/f_pc_load.h +++ b/include/f_pc/f_pc_load.h @@ -1,6 +1,12 @@ -#ifndef F_PC_F_PC_LOAD_H -#define F_PC_F_PC_LOAD_H + +#ifndef F_PC_LOAD_H_ +#define F_PC_LOAD_H_ #include "dolphin/types.h" -#endif /* F_PC_F_PC_LOAD_H */ +BOOL fpcLd_Use(s16 procName); +s32 fpcLd_IsLoaded(s16 procName); +void fpcLd_Free(s16 procName); +s32 fpcLd_Load(s16 procName); + +#endif diff --git a/include/f_pc/f_pc_manager.h b/include/f_pc/f_pc_manager.h index d15e64ac34..cce48a9f76 100644 --- a/include/f_pc/f_pc_manager.h +++ b/include/f_pc/f_pc_manager.h @@ -1,6 +1,36 @@ -#ifndef F_PC_F_PC_MANAGER_H -#define F_PC_F_PC_MANAGER_H +#ifndef F_PC_MANAGER_H_ +#define F_PC_MANAGER_H_ +#include "SSystem/SComponent/c_node_iter.h" +#include "SSystem/SComponent/c_tag.h" +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_create_iter.h" +#include "f_pc/f_pc_node_req.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_MANAGER_H */ +typedef int (*FastCreateReqFunc)(void*); +typedef void (*fpcM_ManagementFunc)(void); +typedef int (*fpcM_DrawIteraterFunc)(void*, void*); + +inline u32 fpcM_GetID(const void* pProc) { + return pProc != NULL ? ((base_process_class*)pProc)->mBsPcId : 0xFFFFFFFF; +} +void fpcM_Draw(void* pProc); +s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc pFunc); +void fpcM_Execute(void* pProc); +s32 fpcM_Delete(void* pProc); +BOOL fpcM_IsCreating(unsigned int pID); +void fpcM_Management(fpcM_ManagementFunc pFunc1, fpcM_ManagementFunc pFunc2); +void fpcM_Init(void); +base_process_class* fpcM_FastCreate(s16 pProcTypeID, FastCreateReqFunc param_2, void* param_3, + void* pData); +s32 fpcM_IsPause(void* pProc, u8 param_2); +void fpcM_PauseEnable(void* pProc, u8 param_2); +void fpcM_PauseDisable(void* pProc, u8 param_2); +void* fpcM_JudgeInLayer(unsigned int pLayerID, fpcCtIt_JudgeFunc pFunc, void* pUserData); + +extern "C" { +void fpcM_Delete__FPv(void); +} + +#endif \ No newline at end of file diff --git a/include/f_pc/f_pc_method.h b/include/f_pc/f_pc_method.h index 7aecf21226..aa7e98dda7 100644 --- a/include/f_pc/f_pc_method.h +++ b/include/f_pc/f_pc_method.h @@ -1,6 +1,27 @@ -#ifndef F_PC_F_PC_METHOD_H -#define F_PC_F_PC_METHOD_H + +#ifndef F_PC_METHOD_H_ +#define F_PC_METHOD_H_ #include "dolphin/types.h" -#endif /* F_PC_F_PC_METHOD_H */ +typedef int (*process_method_func)(void*); + +typedef struct process_method_class { + process_method_func mpCreateFunc; + process_method_func mpDeleteFunc; + process_method_func mpExecuteFunc; + process_method_func mpIsDeleteFunc; +} process_method_class; + +s32 fpcMtd_Method(process_method_func pFunc, void* pUserData); +s32 fpcMtd_Execute(process_method_class* pMthd, void* pUserData); +s32 fpcMtd_IsDelete(process_method_class* pMthd, void* pUserData); +s32 fpcMtd_Delete(process_method_class* pMthd, void* pUserData); +s32 fpcMtd_Create(process_method_class* pMthd, void* pUserData); + +extern "C" { +void fpcMtd_Execute__FP20process_method_classPv(void); +void fpcMtd_Create__FP20process_method_classPv(void); +} + +#endif diff --git a/include/f_pc/f_pc_method_iter.h b/include/f_pc/f_pc_method_iter.h index 8e989b3915..1c3ad4eec4 100644 --- a/include/f_pc/f_pc_method_iter.h +++ b/include/f_pc/f_pc_method_iter.h @@ -1,6 +1,12 @@ -#ifndef F_PC_F_PC_METHOD_ITER_H -#define F_PC_F_PC_METHOD_ITER_H +#ifndef F_PC_METHOD_ITER_H_ +#define F_PC_METHOD_ITER_H_ + +#include "SSystem/SComponent/c_list_iter.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_METHOD_ITER_H */ +typedef int (*fpcMtdIt_MethodFunc)(void*); + +void fpcMtdIt_Method(node_list_class* pList, fpcMtdIt_MethodFunc pMethod); + +#endif diff --git a/include/f_pc/f_pc_method_tag.h b/include/f_pc/f_pc_method_tag.h index fe39eb535a..acaa8a8557 100644 --- a/include/f_pc/f_pc_method_tag.h +++ b/include/f_pc/f_pc_method_tag.h @@ -1,6 +1,21 @@ -#ifndef F_PC_F_PC_METHOD_TAG_H -#define F_PC_F_PC_METHOD_TAG_H +#ifndef F_PC_METHOD_TAG_H_ +#define F_PC_METHOD_TAG_H_ + +#include "SSystem/SComponent/c_tag.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_METHOD_TAG_H */ +typedef int (*process_method_tag_func)(void*); + +typedef struct process_method_tag_class { + create_tag_class mCreateTag; + process_method_tag_func mpFunc; + void* mpMthdData; +} process_method_tag_class; + +s32 fpcMtdTg_Do(process_method_tag_class* pMthd); +s32 fpcMtdTg_ToMethodQ(node_list_class* pList, process_method_tag_class* pMthd); +void fpcMtdTg_MethodQTo(process_method_tag_class* pMthd); +s32 fpcMtdTg_Init(process_method_tag_class* pMthd, process_method_tag_func pFunc, void* pMthdData); + +#endif diff --git a/include/f_pc/f_pc_node.h b/include/f_pc/f_pc_node.h index a7fa12309c..0a6222ab6e 100644 --- a/include/f_pc/f_pc_node.h +++ b/include/f_pc/f_pc_node.h @@ -1,6 +1,41 @@ -#ifndef F_PC_F_PC_NODE_H -#define F_PC_F_PC_NODE_H -#include "dolphin/types.h" +#ifndef F_PC_NODE_H_ +#define F_PC_NODE_H_ -#endif /* F_PC_F_PC_NODE_H */ +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_layer.h" +#include "f_pc/f_pc_method.h" + +typedef struct nodedraw_method_class { + process_method_class mBase; + process_method_func mNodedrawFunc; +} nodedraw_method_class; + +typedef struct process_node_class { + base_process_class mBase; + nodedraw_method_class* mpNodeMtd; + layer_class mLayer; + node_list_class mLayerNodeLists[16]; + s8 mUnk0; +} process_node_class; + +typedef struct node_process_profile_definition { + process_profile_definition mBase; + nodedraw_method_class* mNDrwMthCls; + s16 unk20; + u8 unk22[2]; + s32 unk24; +} node_process_profile_definition; + +s32 fpcNd_DrawMethod(nodedraw_method_class* pNodeMethod, void* pData); +s32 fpcNd_Draw(process_node_class* pProcNode); +s32 fpcNd_Execute(process_node_class* pProcNode); +void* fpcNd_IsCreatingFromUnder(void* pProcNode); +s32 fpcNd_IsDeleteTiming(process_node_class* pProcNode); +s32 fpcNd_IsDelete(process_node_class* pProcNode); +s32 fpcNd_Delete(process_node_class* pProcNode); +s32 fpcNd_Create(process_node_class* pProcNode); + +extern int g_fpcNd_type; + +#endif diff --git a/include/f_pc/f_pc_node_req.h b/include/f_pc/f_pc_node_req.h index ac8afd5746..1513d86671 100644 --- a/include/f_pc/f_pc_node_req.h +++ b/include/f_pc/f_pc_node_req.h @@ -1,6 +1,69 @@ -#ifndef F_PC_F_PC_NODE_REQ_H -#define F_PC_F_PC_NODE_REQ_H +#ifndef F_PC_NODE_REQ_H_ +#define F_PC_NODE_REQ_H_ +#include "SSystem/SComponent/c_phase.h" +#include "f_pc/f_pc_method.h" +#include "f_pc/f_pc_method_tag.h" +#include "f_pc/f_pc_node.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_NODE_REQ_H */ +typedef struct node_create_request_method_class { + process_method_func mpExecuteFunc; + process_method_func mpCancelFunc; + process_method_func mpUnkFunc; + process_method_func mpPostMethodFunc; +} node_create_request_method_class; +// needed to match struct copy +typedef struct unk_process_node_class { + process_node_class* mpNodeProc; + u32 mProcId; +} unk_process_node_class; + +typedef struct node_create_request { + create_tag_class mCreateTag; + process_method_tag_class mProcMthCls; + request_of_phase_process_class mReqPhsProc; + cPhs__Handler* mpPhsHandler; + node_create_request_method_class* mpNodeCrReqMthCls; + s32 mParameter; + s32 mRequestId; + unk_process_node_class mNodeProc; + layer_class* mpLayerClass; + u32 mCreatingID; + s16 mProcName; + void* mpUserData; + s16 unk_0x60; + +} node_create_request; // Size: 0x64 + +typedef struct request_node_class { + node_class mBase; + node_create_request* mNodeCrReq; +} request_node_class; + +void fpcNdRq_RequestQTo(node_create_request* pNodeCreateReq); +void fpcNdRq_ToRequestQ(node_create_request* pNodeCreateReq); +s32 fpcNdRq_phase_IsCreated(node_create_request* pNodeCreateReq); +s32 fpcNdRq_phase_Create(node_create_request* pNodeCreateReq); +s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* pNodeCreateReq); +s32 fpcNdRq_phase_IsDeleted(node_create_request* pNodeCreateReq); +s32 fpcNdRq_phase_Delete(node_create_request* pNodeCreateReq); +s32 fpcNdRq_DoPhase(node_create_request* pNodeCreateReq); +s32 fpcNdRq_Execute(node_create_request* pNodeCreateReq); +s32 fpcNdRq_Delete(node_create_request* pNodeCreateReq); +s32 fpcNdRq_Cancel(node_create_request* pNodeCreateReq); +s32 fpcNdRq_Handler(void); +s32 fpcNdRq_IsPossibleTarget(struct process_node_class* pProcNode); +s32 fpcNdRq_IsIng(struct process_node_class* pProcNode); +node_create_request* fpcNdRq_Create(u32 pRequestSize); +node_create_request* fpcNdRq_ChangeNode(u32 pRequestSize, struct process_node_class* pProcNode, + s16 param_3, void* param_4); +node_create_request* fpcNdRq_DeleteNode(u32 pRequestSize, struct process_node_class* pProcNode); +node_create_request* fpcNdRq_CreateNode(u32 pRequestSize, s16 param_2, void* param_3); +node_create_request* +fpcNdRq_Request(u32 param_1, int param_2, struct process_node_class* param_3, s16 param_4, + void* param_5, node_create_request_method_class* pNodeCreateRequestMethodClass); +s32 fpcNdRq_ReChangeNode(unsigned int pRequestId, s16 param_2, void* param_3); +s32 fpcNdRq_ReRequest(unsigned int pRequestId, s16 param_2, void* param_3); + +#endif \ No newline at end of file diff --git a/include/f_pc/f_pc_pause.h b/include/f_pc/f_pc_pause.h index b59a9076ad..9af24aeb05 100644 --- a/include/f_pc/f_pc_pause.h +++ b/include/f_pc/f_pc_pause.h @@ -1,6 +1,13 @@ -#ifndef F_PC_F_PC_PAUSE_H -#define F_PC_F_PC_PAUSE_H +#ifndef F_PC_PAUSE_ +#define F_PC_PAUSE_ +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_node.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_PAUSE_H */ +s32 fpcPause_IsEnable(void* pProc, u8 expected); +s32 fpcPause_Enable(void* pProc, u8 pauseMask); +s32 fpcPause_Disable(void* pProc, u8 pauseMask); +void fpcPause_Init(void* pProc); + +#endif diff --git a/include/f_pc/f_pc_priority.h b/include/f_pc/f_pc_priority.h index c76b48abaf..81d799eeeb 100644 --- a/include/f_pc/f_pc_priority.h +++ b/include/f_pc/f_pc_priority.h @@ -1,6 +1,32 @@ -#ifndef F_PC_F_PC_PRIORITY_H -#define F_PC_F_PC_PRIORITY_H -#include "dolphin/types.h" +#ifndef F_PC_PRIORITY_H_ +#define F_PC_PRIORITY_H_ -#endif /* F_PC_F_PC_PRIORITY_H */ +#include "SSystem/SComponent/c_tag.h" +#include "f_pc/f_pc_method_tag.h" + +typedef struct process_priority_queue_info { + u32 mLayer; + u16 mListID; + u16 mListPrio; +} process_priority_queue_info; + +typedef struct process_priority_class { + /* 0x00 */ create_tag_class mBase; + /* 0x14 */ process_method_tag_class mMtdTag; + /* 0x30 */ process_priority_queue_info mInfoQ; + /* 0x38 */ process_priority_queue_info mInfoCurr; +} process_priority_class; + +s32 fpcPi_IsInQueue(process_priority_class* pPi); +s32 fpcPi_QueueTo(process_priority_class* pPi); +s32 fpcPi_ToQueue(process_priority_class* pPi); +process_priority_class* fpcPi_GetFromQueue(void); +s32 fpcPi_Delete(process_priority_class* pPi); +s32 fpcPi_IsNormal(unsigned int layer, u16 listID, u16 priority); +s32 fpcPi_Change(process_priority_class* pPi, unsigned int layer, u16 listID, u16 priority); +s32 fpcPi_Handler(void); +s32 fpcPi_Init(process_priority_class* pPi, void* pUserData, unsigned int layer, u16 listID, + u16 priority); + +#endif diff --git a/include/f_pc/f_pc_profile.h b/include/f_pc/f_pc_profile.h index ad759384ee..db969056e9 100644 --- a/include/f_pc/f_pc_profile.h +++ b/include/f_pc/f_pc_profile.h @@ -1,6 +1,26 @@ -#ifndef F_PC_F_PC_PROFILE_H -#define F_PC_F_PC_PROFILE_H +#ifndef F_PC_PROFILE_H_ +#define F_PC_PROFILE_H_ + +#include "f_pc/f_pc_method.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_PROFILE_H */ +struct nodedraw_method_class; + +typedef struct process_profile_definition { + s32 mLayerID; + u16 mListID; + u16 mListPrio; + s16 mProcName; + s16 unkA; // probably padding + struct process_method_class* mpPcMtd; + s32 mSize; + s32 mSizeOther; + s32 mParameters; +} process_profile_definition; + +process_profile_definition* fpcPf_Get(s16 profileID); + +extern process_profile_definition** g_fpcPf_ProfileList_p; + +#endif diff --git a/include/f_pc/f_pc_searcher.h b/include/f_pc/f_pc_searcher.h index d3e5e012e8..01b8ed5dd0 100644 --- a/include/f_pc/f_pc_searcher.h +++ b/include/f_pc/f_pc_searcher.h @@ -1,6 +1,15 @@ -#ifndef F_PC_F_PC_SEARCHER_H -#define F_PC_F_PC_SEARCHER_H +#ifndef F_PC_SEARCHER_H_ +#define F_PC_SEARCHER_H_ + +#include "f_pc/f_pc_base.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_SEARCHER_H */ +void* fpcSch_JudgeForPName(void* pProc, void* pUserData); +void* fpcSch_JudgeByID(void* pProc, void* pUserData); + +extern "C" { +void fpcSch_JudgeForPName__FPvPv(void); +} + +#endif diff --git a/include/f_pc/f_pc_stdcreate_req.h b/include/f_pc/f_pc_stdcreate_req.h index b72e80694c..bb38c1c079 100644 --- a/include/f_pc/f_pc_stdcreate_req.h +++ b/include/f_pc/f_pc_stdcreate_req.h @@ -1,6 +1,34 @@ -#ifndef F_PC_F_PC_STDCREATE_REQ_H -#define F_PC_F_PC_STDCREATE_REQ_H +#ifndef F_PC_STDCREATE_H_ +#define F_PC_STDCREATE_H_ +#include "f_pc/f_pc_create_req.h" +#include "f_pc/f_pc_layer.h" #include "dolphin/types.h" -#endif /* F_PC_F_PC_STDCREATE_REQ_H */ +typedef int (*stdCreateFunc)(void*, void*); + +typedef struct standard_create_request_class { + /* 0x00 */ create_request mBase; + /* 0x48 */ request_of_phase_process_class unk_0x48; + /* 0x50 */ s16 mLoadID; + /* 0x54 */ void* unk_0x54; + /* 0x58 */ stdCreateFunc unk_0x58; + /* 0x5C */ void* unk_0x5C; +} standard_create_request_class; + +s32 fpcSCtRq_phase_CreateProcess(standard_create_request_class* pStdCreateReq); +s32 fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* pStdCreateReq); +s32 fpcSCtRq_phase_IsComplete(standard_create_request_class* pStdCreateReq); +s32 fpcSCtRq_phase_PostMethod(standard_create_request_class* pStdCreateReq); +s32 fpcSCtRq_phase_Done(standard_create_request_class*); +s32 fpcSCtRq_Handler(standard_create_request_class* pStdCreateReq); +s32 fpcSCtRq_Delete(standard_create_request_class*); +s32 fpcSCtRq_Cancel(standard_create_request_class*); +s32 fpcSCtRq_Request(layer_class* param_1, s16 param_2, stdCreateFunc param_3, void* param_4, + void* param_5); + +extern "C" { +void fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv(void); +} + +#endif \ No newline at end of file diff --git a/libs/SSystem/SStandard/s_basic.cpp b/libs/SSystem/SStandard/s_basic.cpp index 788d927dab..e6b9595266 100644 --- a/libs/SSystem/SStandard/s_basic.cpp +++ b/libs/SSystem/SStandard/s_basic.cpp @@ -7,40 +7,16 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Forward References: -// - -static void sBs_FillArea_s(void*, u32, s16); -void sBs_ClearArea(void*, u32); - -extern "C" static void sBs_FillArea_s__FPvUls(); -extern "C" void sBs_ClearArea__FPvUl(); - -// -// External References: -// - -// -// Declarations: -// - /* 80271C8C-80271CAC 0020+00 s=1 e=0 z=0 None .text sBs_FillArea_s__FPvUls */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void sBs_FillArea_s(void* param_0, u32 param_1, s16 param_2) { - nofralloc -#include "asm/SSystem/SStandard/s_basic/sBs_FillArea_s__FPvUls.s" +void sBs_FillArea_s(void* pPtr, u32 pNumBytes, s16 pValue) { + s16* castPtr = (s16*)pPtr; + for (int i = 0; i < pNumBytes / 2; i++) { + *castPtr = pValue; + castPtr++; + } } -#pragma pop /* 80271CAC-80271CD0 0024+00 s=0 e=2 z=0 None .text sBs_ClearArea__FPvUl */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void sBs_ClearArea(void* param_0, u32 param_1) { - nofralloc -#include "asm/SSystem/SStandard/s_basic/sBs_ClearArea__FPvUl.s" +void sBs_ClearArea(void* pPtr, u32 pNumBytes) { + sBs_FillArea_s(pPtr, pNumBytes, 0); } -#pragma pop diff --git a/src/f_pc/f_pc_base.cpp b/src/f_pc/f_pc_base.cpp index 2ee8862dfb..3717aa51e8 100644 --- a/src/f_pc/f_pc_base.cpp +++ b/src/f_pc/f_pc_base.cpp @@ -7,193 +7,135 @@ #include "dol2asm.h" #include "dolphin/types.h" #include "SSystem/SComponent/c_malloc.h" +#include "f_pc/f_pc_pause.h" +#include "SSystem/SComponent/c_phase.h" +#include "SSystem/SStandard/s_basic.h" -// -// Types: -// - -struct process_priority_class {}; - -struct process_method_class {}; - -struct line_tag {}; - -struct layer_management_tag_class {}; - -struct layer_class {}; - -struct delete_tag_class {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcBs_MakeOfType(int*); -void fpcBs_MakeOfId(); -void fpcBs_Execute(base_process_class*); -static void fpcBs_DeleteAppend(base_process_class*); -void fpcBs_IsDelete(base_process_class*); -void fpcBs_Delete(base_process_class*); -void fpcBs_Create(s16, unsigned int, void*); -void fpcBs_SubCreate(base_process_class*); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcBs_MakeOfType__FPi(); -extern "C" void fpcBs_MakeOfId__Fv(); -extern "C" void fpcBs_Execute__FP18base_process_class(); -extern "C" static void fpcBs_DeleteAppend__FP18base_process_class(); -extern "C" void fpcBs_IsDelete__FP18base_process_class(); -extern "C" void fpcBs_Delete__FP18base_process_class(); -extern "C" void fpcBs_Create__FsUiPv(); -extern "C" void fpcBs_SubCreate__FP18base_process_class(); - -// -// External References: -// - -void fpcDtTg_Init(delete_tag_class*, void*); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_CurrentLayer(); -void fpcLyTg_Init(layer_management_tag_class*, unsigned int, void*); -void fpcMtd_Execute(process_method_class*, void*); -void fpcMtd_IsDelete(process_method_class*, void*); -void fpcMtd_Delete(process_method_class*, void*); -void fpcMtd_Create(process_method_class*, void*); -void fpcPi_Init(process_priority_class*, void*, unsigned int, u16, u16); -void fpcPf_Get(s16); -void fpcLnTg_Init(line_tag*, void*); -void fpcPause_Init(void*); -void sBs_ClearArea(void*, u32); - -extern "C" void fpcDtTg_Init__FP16delete_tag_classPv(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" void fpcLyTg_Init__FP26layer_management_tag_classUiPv(); -extern "C" void fpcMtd_Execute__FP20process_method_classPv(); -extern "C" void fpcMtd_IsDelete__FP20process_method_classPv(); -extern "C" void fpcMtd_Delete__FP20process_method_classPv(); -extern "C" void fpcMtd_Create__FP20process_method_classPv(); -extern "C" void fpcPi_Init__FP22process_priority_classPvUiUsUs(); -extern "C" void fpcPf_Get__Fs(); -extern "C" void fpcLnTg_Init__FP8line_tagPv(); -extern "C" void fpcPause_Init__FPv(); -extern "C" void memalignB__3cMlFiUl(); -extern "C" void free__3cMlFPv(); -extern "C" void sBs_ClearArea__FPvUl(); -extern "C" void _savegpr_26(); -extern "C" void _restgpr_26(); +// hack to make functions that return comparisons as int match +extern int __cntlzw(unsigned int); +inline BOOL checkEqual(s32 a, s32 b) { + return (u32)__cntlzw(a - b) >> 5; +} // // Declarations: // /* 8002064C-8002065C 0010+00 s=0 e=14 z=0 None .text fpcBs_Is_JustOfType__Fii */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_Is_JustOfType(int param_0, int param_1) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_Is_JustOfType__Fii.s" +BOOL fpcBs_Is_JustOfType(int pType1, int pType2) { + return checkEqual(pType1, pType2); } -#pragma pop /* ############################################################################################## */ /* 80450D00-80450D04 0004+00 s=1 e=0 z=0 None .sbss g_fpcBs_type */ -static u8 g_fpcBs_type[4]; - -/* 80450D04-80450D08 0004+00 s=1 e=0 z=0 None .sbss t_type$2207 */ -static u8 t_type[4]; - -/* 80450D08-80450D0C 0004+00 s=1 e=0 z=0 None .sbss None */ -static u8 data_80450D08[4]; +static int g_fpcBs_type; /* 8002065C-8002069C 0040+00 s=1 e=5 z=0 None .text fpcBs_MakeOfType__FPi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_MakeOfType(int* param_0) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_MakeOfType__FPi.s" +s32 fpcBs_MakeOfType(int* pType) { + static s32 t_type = 0x9130000; + if (*pType == 0) { + *pType = ++t_type; + } + return *pType; } -#pragma pop - -/* ############################################################################################## */ -/* 80450D0C-80450D10 0004+00 s=1 e=0 z=0 None .sbss process_id$2216 */ -static u8 process_id[4]; - -/* 80450D10-80450D18 0008+00 s=1 e=0 z=0 None .sbss None */ -static u8 data_80450D10[8]; /* 8002069C-800206C4 0028+00 s=0 e=2 z=0 None .text fpcBs_MakeOfId__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_MakeOfId() { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_MakeOfId__Fv.s" +s32 fpcBs_MakeOfId(void) { + static s32 process_id = 1; + return process_id++; } -#pragma pop /* 800206C4-80020720 005C+00 s=0 e=1 z=0 None .text fpcBs_Execute__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_Execute(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_Execute__FP18base_process_class.s" +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; } -#pragma pop /* 80020720-80020760 0040+00 s=2 e=0 z=0 None .text fpcBs_DeleteAppend__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcBs_DeleteAppend(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_DeleteAppend__FP18base_process_class.s" +void fpcBs_DeleteAppend(base_process_class* pProc) { + if (pProc->mpUserData != NULL) { + cMl::free(pProc->mpUserData); + pProc->mpUserData = NULL; + } } -#pragma pop /* 80020760-800207BC 005C+00 s=0 e=1 z=0 None .text fpcBs_IsDelete__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_IsDelete(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_IsDelete__FP18base_process_class.s" +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; } -#pragma pop /* 800207BC-80020820 0064+00 s=0 e=2 z=0 None .text fpcBs_Delete__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_Delete(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_Delete__FP18base_process_class.s" +s32 fpcBs_Delete(base_process_class* pProc) { + s32 deleteResult = fpcMtd_Delete(pProc->mpPcMtd, pProc); + if (deleteResult == 1) { + fpcBs_DeleteAppend(pProc); + pProc->mBsType = 0; + cMl::free(pProc); + } + return deleteResult; } -#pragma pop /* 80020820-8002091C 00FC+00 s=0 e=2 z=0 None .text fpcBs_Create__FsUiPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_Create(s16 param_0, unsigned int param_1, void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_Create__FsUiPv.s" -} -#pragma pop +base_process_class* fpcBs_Create(s16 pProcTypeID, unsigned int pProcID, void* pData) { + process_profile_definition* procProfDef; + base_process_class* procClass; + u32 size; -/* 8002091C-800209C8 00AC+00 s=0 e=2 z=0 None .text fpcBs_SubCreate__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcBs_SubCreate(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_base/fpcBs_SubCreate__FP18base_process_class.s" + procProfDef = fpcPf_Get(pProcTypeID); + size = procProfDef->mSize + procProfDef->mSizeOther; + procClass = (base_process_class*)cMl::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(&g_fpcBs_type); + 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; + } } -#pragma pop diff --git a/src/f_pc/f_pc_create_iter.cpp b/src/f_pc/f_pc_create_iter.cpp index 4041222c79..5daf12a44d 100644 --- a/src/f_pc/f_pc_create_iter.cpp +++ b/src/f_pc/f_pc_create_iter.cpp @@ -6,95 +6,44 @@ #include "f_pc/f_pc_create_iter.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct node_list_class {}; - -struct node_class {}; - -struct method_filter {}; - -struct judge_filter {}; - -struct fpcCtIt_jilprm_c {}; - -struct create_tag_class {}; - -struct create_tag {}; - -// -// Forward References: -// - -void fpcCtIt_Method(int (*)(void*, void*), void*); -void fpcCtIt_Judge(void* (*)(void*, void*), void*); -static void fpcCtIt_filter_JudgeInLayer(create_tag*, fpcCtIt_jilprm_c*); -void fpcCtIt_JudgeInLayer(unsigned int, void* (*)(void*, void*), void*); - -extern "C" void fpcCtIt_Method__FPFPvPv_iPv(); -extern "C" void fpcCtIt_Judge__FPFPvPv_PvPv(); -extern "C" static void fpcCtIt_filter_JudgeInLayer__FP10create_tagP16fpcCtIt_jilprm_c(); -extern "C" void fpcCtIt_JudgeInLayer__FUiPFPvPv_PvPv(); - -// -// External References: -// - -void cLsIt_Method(node_list_class*, int (*)(node_class*, void*), void*); -void cLsIt_Judge(node_list_class*, void* (*)(node_class*, void*), void*); -void cTgIt_MethodCall(create_tag_class*, method_filter*); -void cTgIt_JudgeFilter(create_tag_class*, judge_filter*); - -extern "C" void cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv(); -extern "C" void cLsIt_Judge__FP15node_list_classPFP10node_classPv_PvPv(); -extern "C" void cTgIt_MethodCall__FP16create_tag_classP13method_filter(); -extern "C" void cTgIt_JudgeFilter__FP16create_tag_classP12judge_filter(); -extern "C" extern u8 g_fpcCtTg_Queue[12 + 4 /* padding */]; +#include "f_pc/f_pc_create_req.h" // // Declarations: // /* 800209C8-80020A04 003C+00 s=0 e=1 z=0 None .text fpcCtIt_Method__FPFPvPv_iPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtIt_Method(int (*)(void*, void*), void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_create_iter/fpcCtIt_Method__FPFPvPv_iPv.s" +s32 fpcCtIt_Method(fpcCtIt_MethodFunc pJudge, void* pUserData) { + node_method_data iter; + iter.mFunc = pJudge; + iter.mpUserData = pUserData; + return cLsIt_Method(&g_fpcCtTg_Queue, (cNdIt_MethodFunc)cTgIt_MethodCall, &iter); } -#pragma pop /* 80020A04-80020A40 003C+00 s=1 e=2 z=0 None .text fpcCtIt_Judge__FPFPvPv_PvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtIt_Judge(void* (*)(void*, void*), void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_create_iter/fpcCtIt_Judge__FPFPvPv_PvPv.s" +void* fpcCtIt_Judge(fpcCtIt_JudgeFunc pJudge, void* pUserData) { + node_judge_data iter; + iter.mFunc = pJudge; + iter.mpUserData = pUserData; + return cLsIt_Judge(&g_fpcCtTg_Queue, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &iter); } -#pragma pop /* 80020A40-80020A94 0054+00 s=1 e=0 z=0 None .text * fpcCtIt_filter_JudgeInLayer__FP10create_tagP16fpcCtIt_jilprm_c */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcCtIt_filter_JudgeInLayer(create_tag* param_0, fpcCtIt_jilprm_c* param_1) { - nofralloc -#include "asm/f_pc/f_pc_create_iter/fpcCtIt_filter_JudgeInLayer__FP10create_tagP16fpcCtIt_jilprm_c.s" +void* fpcCtIt_filter_JudgeInLayer(create_tag* pCreateTag, fpcCtIt_jilprm_c* pIterData) { + create_request* create_req = static_cast(pCreateTag->mBase.mpTagData); + if (create_req->mpLayer->mLayerID == pIterData->mLayerID) { + return pIterData->mFunc((node_class*)create_req->mpRes, pIterData->mpUserData); + } else { + return NULL; + } } -#pragma pop /* 80020A94-80020ACC 0038+00 s=0 e=1 z=0 None .text fpcCtIt_JudgeInLayer__FUiPFPvPv_PvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtIt_JudgeInLayer(unsigned int param_0, void* (*)(void*, void*), void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_create_iter/fpcCtIt_JudgeInLayer__FUiPFPvPv_PvPv.s" +void* fpcCtIt_JudgeInLayer(unsigned int pLayerID, fpcCtIt_JudgeFunc pFunc, void* pUserData) { + fpcCtIt_jilprm_c data; + data.mLayerID = pLayerID; + data.mFunc = pFunc; + data.mpUserData = pUserData; + return fpcCtIt_Judge((fpcCtIt_JudgeFunc)fpcCtIt_filter_JudgeInLayer, &data); } -#pragma pop diff --git a/src/f_pc/f_pc_create_req.cpp b/src/f_pc/f_pc_create_req.cpp index 9e02b4923b..8850f1d87f 100644 --- a/src/f_pc/f_pc_create_req.cpp +++ b/src/f_pc/f_pc_create_req.cpp @@ -6,91 +6,18 @@ #include "f_pc/f_pc_create_req.h" #include "dol2asm.h" #include "dolphin/types.h" +#include "f_pc/f_pc_create_iter.h" +#include "f_pc/f_pc_layer_iter.h" +#include "SSystem/SComponent/c_malloc.h" +#include "f_pc/f_pc_create_tag.h" +#include "f_pc/f_pc_deletor.h" +#include "f_pc/f_pc_executor.h" -// -// Types: -// - -struct process_method_tag_class {}; - -struct layer_class {}; - -struct create_tag {}; - -struct create_request_method_class {}; - -struct create_request {}; - -struct cMl { - /* 80263228 */ void memalignB(int, u32); - /* 80263260 */ void free(void*); -}; - -struct base_process_class {}; - -// -// Forward References: -// - -static void fpcCtRq_isCreatingByID(create_tag*, unsigned int*); -void fpcCtRq_IsCreatingByID(unsigned int); -static void fpcCtRq_CreateQTo(create_request*); -static void fpcCtRq_ToCreateQ(create_request*); -static void fpcCtRq_Delete(create_request*); -void fpcCtRq_Cancel(create_request*); -void fpcCtRq_IsDoing(create_request*); -static void fpcCtRq_Do(create_request*); -void fpcCtRq_Handler(); -void fpcCtRq_Create(layer_class*, u32, create_request_method_class*); - -extern "C" static void fpcCtRq_isCreatingByID__FP10create_tagPUi(); -extern "C" void fpcCtRq_IsCreatingByID__FUi(); -extern "C" static void fpcCtRq_CreateQTo__FP14create_request(); -extern "C" static void fpcCtRq_ToCreateQ__FP14create_request(); -extern "C" static void fpcCtRq_Delete__FP14create_request(); -extern "C" void fpcCtRq_Cancel__FP14create_request(); -extern "C" void fpcCtRq_IsDoing__FP14create_request(); -extern "C" static void fpcCtRq_Do__FP14create_request(); -extern "C" void fpcCtRq_Handler__Fv(); -extern "C" void fpcCtRq_Create__FP11layer_classUlP27create_request_method_class(); - -// -// External References: -// - -void fpcBs_MakeOfId(); -void fpcCtIt_Method(int (*)(void*, void*), void*); -void fpcCtIt_Judge(void* (*)(void*, void*), void*); -void fpcCtTg_ToCreateQ(create_tag*); -void fpcCtTg_CreateQTo(create_tag*); -void fpcCtTg_Init(create_tag*, void*); -void fpcDt_Delete(void*); -void fpcEx_ToExecuteQ(base_process_class*); -void fpcLy_CancelQTo(process_method_tag_class*); -void fpcLy_ToCancelQ(layer_class*, process_method_tag_class*); -void fpcLy_CreatingMesg(layer_class*); -void fpcLy_CreatedMesg(layer_class*); -void fpcMtd_Method(int (*)(void*), void*); -void fpcMtdTg_Init(process_method_tag_class*, int (*)(void*), void*); - -extern "C" void fpcBs_MakeOfId__Fv(); -extern "C" void fpcCtIt_Method__FPFPvPv_iPv(); -extern "C" void fpcCtIt_Judge__FPFPvPv_PvPv(); -extern "C" void fpcCtTg_ToCreateQ__FP10create_tag(); -extern "C" void fpcCtTg_CreateQTo__FP10create_tag(); -extern "C" void fpcCtTg_Init__FP10create_tagPv(); -extern "C" void fpcDt_Delete__FPv(); -extern "C" void fpcEx_ToExecuteQ__FP18base_process_class(); -extern "C" void fpcLy_CancelQTo__FP24process_method_tag_class(); -extern "C" void fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class(); -extern "C" void fpcLy_CreatingMesg__FP11layer_class(); -extern "C" void fpcLy_CreatedMesg__FP11layer_class(); -extern "C" void fpcMtd_Method__FPFPv_iPv(); -extern "C" void fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv(); -extern "C" void memalignB__3cMlFiUl(); -extern "C" void free__3cMlFPv(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_29(); +// hack to make functions that return comparisons as int match +extern int __cntlzw(unsigned int); +inline BOOL checkEqual(s32 a, s32 b) { + return (u32)__cntlzw(a - b) >> 5; +} // // Declarations: @@ -98,102 +25,121 @@ extern "C" void _restgpr_29(); /* 80020ACC-80020AE8 001C+00 s=1 e=0 z=0 None .text fpcCtRq_isCreatingByID__FP10create_tagPUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcCtRq_isCreatingByID(create_tag* param_0, unsigned int* param_1) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_isCreatingByID__FP10create_tagPUi.s" +BOOL fpcCtRq_isCreatingByID(create_tag* pTag, unsigned int* pId) { + create_request* pReq = static_cast(pTag->mBase.mpTagData); + return checkEqual(*pId, pReq->mBsPcId); } -#pragma pop /* 80020AE8-80020B20 0038+00 s=0 e=2 z=0 None .text fpcCtRq_IsCreatingByID__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtRq_IsCreatingByID(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_IsCreatingByID__FUi.s" +BOOL fpcCtRq_IsCreatingByID(unsigned int id) { + return fpcCtIt_Judge((fpcLyIt_JudgeFunc)fpcCtRq_isCreatingByID, &id) != NULL ? 1 : 0; } -#pragma pop /* 80020B20-80020B5C 003C+00 s=1 e=0 z=0 None .text fpcCtRq_CreateQTo__FP14create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcCtRq_CreateQTo(create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_CreateQTo__FP14create_request.s" +void fpcCtRq_CreateQTo(create_request* pReq) { + fpcCtTg_CreateQTo(&pReq->mBase); + fpcLy_CreatedMesg(pReq->mpLayer); + fpcLy_CancelQTo(&pReq->mMtdTg); } -#pragma pop /* 80020B5C-80020BA0 0044+00 s=1 e=0 z=0 None .text fpcCtRq_ToCreateQ__FP14create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcCtRq_ToCreateQ(create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_ToCreateQ__FP14create_request.s" +void fpcCtRq_ToCreateQ(create_request* pReq) { + fpcLy_CreatingMesg(pReq->mpLayer); + fpcLy_ToCancelQ(pReq->mpLayer, &pReq->mMtdTg); + fpcCtTg_ToCreateQ(&pReq->mBase); } -#pragma pop /* 80020BA0-80020C14 0074+00 s=2 e=0 z=0 None .text fpcCtRq_Delete__FP14create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcCtRq_Delete(create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_Delete__FP14create_request.s" +BOOL fpcCtRq_Delete(create_request* pReq) { + fpcCtRq_CreateQTo(pReq); + if (pReq->mpCtRqMtd != NULL && fpcMtd_Method(pReq->mpCtRqMtd->mpDelete, pReq) == 0) { + return 0; + } else { + if (pReq->mpRes) { + pReq->mpRes->mpCtRq = NULL; + } + cMl::free(pReq); + return 1; + } } -#pragma pop /* 80020C14-80020CAC 0098+00 s=2 e=2 z=0 None .text fpcCtRq_Cancel__FP14create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtRq_Cancel(create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_Cancel__FP14create_request.s" +BOOL fpcCtRq_Cancel(create_request* pReq) { + base_process_class* pProc; + if (pReq != NULL && !pReq->mbIsCancelling) { + pReq->mbIsCancelling = TRUE; + pProc = pReq->mpRes; + + if (pProc != NULL && !fpcDt_Delete(pProc)) + return FALSE; + + if (pReq->mpCtRqMtd != NULL && !fpcMtd_Method(pReq->mpCtRqMtd->mpCancel, pReq)) + return FALSE; + + return fpcCtRq_Delete(pReq); + } else { + return TRUE; + } } -#pragma pop /* 80020CAC-80020CC8 001C+00 s=0 e=1 z=0 None .text fpcCtRq_IsDoing__FP14create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtRq_IsDoing(create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_IsDoing__FP14create_request.s" +s32 fpcCtRq_IsDoing(create_request* pReq) { + if (pReq != NULL) + return pReq->mbIsCreating; + else + return FALSE; } -#pragma pop /* 80020CC8-80020D84 00BC+00 s=1 e=0 z=0 None .text fpcCtRq_Do__FP14create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcCtRq_Do(create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_Do__FP14create_request.s" +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; + ret = pHandler(pReq); + pReq->mbIsCreating = FALSE; + } + } + + switch (ret) { + case cPhs_COMPLEATE_e: { + s32 success = fpcEx_ToExecuteQ(pReq->mpRes); + if (success == 0) + return fpcCtRq_Cancel(pReq); + else + return fpcCtRq_Delete(pReq); + } + case 3: + case cPhs_ERROR_e: + return fpcCtRq_Cancel(pReq); + } + + return 1; } -#pragma pop /* 80020D84-80020DB0 002C+00 s=0 e=1 z=0 None .text fpcCtRq_Handler__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtRq_Handler() { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_Handler__Fv.s" + +void fpcCtRq_Handler(void) { + fpcCtIt_Method((fpcCtIt_MethodFunc)fpcCtRq_Do, NULL); } -#pragma pop /* 80020DB0-80020E38 0088+00 s=0 e=2 z=0 None .text * fpcCtRq_Create__FP11layer_classUlP27create_request_method_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtRq_Create(layer_class* param_0, u32 param_1, create_request_method_class* param_2) { - nofralloc -#include "asm/f_pc/f_pc_create_req/fpcCtRq_Create__FP11layer_classUlP27create_request_method_class.s" +create_request* fpcCtRq_Create(layer_class* pLayer, u32 size, create_request_method_class* pMthd) { + create_request* pReq = (create_request*)cMl::memalignB(-4, size); + + if (pReq != NULL) { + 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; + fpcCtRq_ToCreateQ(pReq); + } + + return pReq; } -#pragma pop diff --git a/src/f_pc/f_pc_create_tag.cpp b/src/f_pc/f_pc_create_tag.cpp index 57379c66b0..08e513b116 100644 --- a/src/f_pc/f_pc_create_tag.cpp +++ b/src/f_pc/f_pc_create_tag.cpp @@ -7,93 +7,26 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct node_list_class {}; - -struct create_tag_class {}; - -struct create_tag {}; - -// -// Forward References: -// - -void fpcCtTg_ToCreateQ(create_tag*); -void fpcCtTg_CreateQTo(create_tag*); -void fpcCtTg_Init(create_tag*, void*); - -extern "C" void fpcCtTg_ToCreateQ__FP10create_tag(); -extern "C" void fpcCtTg_CreateQTo__FP10create_tag(); -extern "C" void fpcCtTg_Init__FP10create_tagPv(); -extern "C" extern u8 g_fpcCtTg_Queue[12 + 4 /* padding */]; - -// -// External References: -// - -void cTg_SingleCut(create_tag_class*); -void cTg_Addition(node_list_class*, create_tag_class*); -void cTg_Create(create_tag_class*, void*); - -extern "C" void cTg_SingleCut__FP16create_tag_class(); -extern "C" void cTg_Addition__FP15node_list_classP16create_tag_class(); -extern "C" void cTg_Create__FP16create_tag_classPv(); - // // Declarations: // /* ############################################################################################## */ /* 803A3990-803A39A0 000C+04 s=1 e=2 z=0 None .data g_fpcCtTg_Queue */ -SECTION_DATA u8 g_fpcCtTg_Queue[12 + 4 /* padding */] = { - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - /* padding */ - 0x00, - 0x00, - 0x00, - 0x00, -}; +node_list_class g_fpcCtTg_Queue = {NULL, NULL, 0}; /* 80020E38-80020E64 002C+00 s=0 e=1 z=0 None .text fpcCtTg_ToCreateQ__FP10create_tag */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtTg_ToCreateQ(create_tag* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_tag/fpcCtTg_ToCreateQ__FP10create_tag.s" +void fpcCtTg_ToCreateQ(create_tag* pTag) { + cTg_Addition(&g_fpcCtTg_Queue, &pTag->mBase); } -#pragma pop /* 80020E64-80020E84 0020+00 s=0 e=1 z=0 None .text fpcCtTg_CreateQTo__FP10create_tag */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtTg_CreateQTo(create_tag* param_0) { - nofralloc -#include "asm/f_pc/f_pc_create_tag/fpcCtTg_CreateQTo__FP10create_tag.s" +void fpcCtTg_CreateQTo(create_tag* pTag) { + cTg_SingleCut(&pTag->mBase); } -#pragma pop /* 80020E84-80020EA8 0024+00 s=0 e=1 z=0 None .text fpcCtTg_Init__FP10create_tagPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCtTg_Init(create_tag* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_create_tag/fpcCtTg_Init__FP10create_tagPv.s" +s32 fpcCtTg_Init(create_tag* pTag, void* pUserData) { + cTg_Create(&pTag->mBase, pUserData); + return 1; } -#pragma pop diff --git a/src/f_pc/f_pc_creator.cpp b/src/f_pc/f_pc_creator.cpp index b76a6208e9..8438677dfd 100644 --- a/src/f_pc/f_pc_creator.cpp +++ b/src/f_pc/f_pc_creator.cpp @@ -6,83 +6,29 @@ #include "f_pc/f_pc_creator.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct create_request {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcCt_IsCreatingByID(unsigned int); -void fpcCt_IsDoing(base_process_class*); -void fpcCt_Abort(base_process_class*); -void fpcCt_Handler(); - -extern "C" void fpcCt_IsCreatingByID__FUi(); -extern "C" void fpcCt_IsDoing__FP18base_process_class(); -extern "C" void fpcCt_Abort__FP18base_process_class(); -extern "C" void fpcCt_Handler__Fv(); - -// -// External References: -// - -void fpcCtRq_IsCreatingByID(unsigned int); -void fpcCtRq_Cancel(create_request*); -void fpcCtRq_IsDoing(create_request*); -void fpcCtRq_Handler(); - -extern "C" void fpcCtRq_IsCreatingByID__FUi(); -extern "C" void fpcCtRq_Cancel__FP14create_request(); -extern "C" void fpcCtRq_IsDoing__FP14create_request(); -extern "C" void fpcCtRq_Handler__Fv(); +#include "f_pc/f_pc_create_req.h" +#include "f_pc/f_pc_base.h" // // Declarations: // /* 80020EA8-80020EC8 0020+00 s=0 e=1 z=0 None .text fpcCt_IsCreatingByID__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCt_IsCreatingByID(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_creator/fpcCt_IsCreatingByID__FUi.s" +BOOL fpcCt_IsCreatingByID(unsigned int id) { + return fpcCtRq_IsCreatingByID(id); } -#pragma pop /* 80020EC8-80020EEC 0024+00 s=0 e=1 z=0 None .text fpcCt_IsDoing__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCt_IsDoing(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_creator/fpcCt_IsDoing__FP18base_process_class.s" +s32 fpcCt_IsDoing(base_process_class* pProc) { + return fpcCtRq_IsDoing(pProc->mpCtRq); } -#pragma pop /* 80020EEC-80020F10 0024+00 s=0 e=1 z=0 None .text fpcCt_Abort__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCt_Abort(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_creator/fpcCt_Abort__FP18base_process_class.s" +BOOL fpcCt_Abort(base_process_class* pProc) { + return fpcCtRq_Cancel(pProc->mpCtRq); } -#pragma pop /* 80020F10-80020F30 0020+00 s=0 e=1 z=0 None .text fpcCt_Handler__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcCt_Handler() { - nofralloc -#include "asm/f_pc/f_pc_creator/fpcCt_Handler__Fv.s" +void fpcCt_Handler(void) { + fpcCtRq_Handler(); } -#pragma pop diff --git a/src/f_pc/f_pc_delete_tag.cpp b/src/f_pc/f_pc_delete_tag.cpp index 59e7361715..cd9ec2d1f5 100644 --- a/src/f_pc/f_pc_delete_tag.cpp +++ b/src/f_pc/f_pc_delete_tag.cpp @@ -7,44 +7,12 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// -struct node_list_class {}; - -struct delete_tag_class {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcDtTg_IsEmpty(); -void fpcDtTg_ToDeleteQ(delete_tag_class*); -static void fpcDtTg_DeleteQTo(delete_tag_class*); -void fpcDtTg_Do(delete_tag_class*, int (*)(void*)); -void fpcDtTg_Init(delete_tag_class*, void*); - -extern "C" void fpcDtTg_IsEmpty__Fv(); -extern "C" void fpcDtTg_ToDeleteQ__FP16delete_tag_class(); -extern "C" static void fpcDtTg_DeleteQTo__FP16delete_tag_class(); -extern "C" void fpcDtTg_Do__FP16delete_tag_classPFPv_i(); -extern "C" void fpcDtTg_Init__FP16delete_tag_classPv(); -extern "C" extern u8 g_fpcDtTg_Queue[12 + 4 /* padding */]; - -// -// External References: -// - -void cTg_SingleCut(create_tag_class*); -void cTg_Addition(node_list_class*, create_tag_class*); -void cTg_Create(create_tag_class*, void*); - -extern "C" void cTg_SingleCut__FP16create_tag_class(); -extern "C" void cTg_Addition__FP15node_list_classP16create_tag_class(); -extern "C" void cTg_Create__FP16create_tag_classPv(); +// hack to make functions that return comparisons as int match +extern int __cntlzw(unsigned int); +inline BOOL checkEqual(s32 a, s32 b) { + return (u32)__cntlzw(a - b) >> 5; +} // // Declarations: @@ -52,72 +20,44 @@ extern "C" void cTg_Create__FP16create_tag_classPv(); /* ############################################################################################## */ /* 803A39A0-803A39B0 000C+04 s=2 e=1 z=0 None .data g_fpcDtTg_Queue */ -SECTION_DATA u8 g_fpcDtTg_Queue[12 + 4 /* padding */] = { - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - /* padding */ - 0x00, - 0x00, - 0x00, - 0x00, -}; +node_list_class g_fpcDtTg_Queue = {NULL, NULL, 0}; /* 80020F30-80020F48 0018+00 s=0 e=1 z=0 None .text fpcDtTg_IsEmpty__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDtTg_IsEmpty() { - nofralloc -#include "asm/f_pc/f_pc_delete_tag/fpcDtTg_IsEmpty__Fv.s" +BOOL fpcDtTg_IsEmpty(void) { + return checkEqual(g_fpcDtTg_Queue.mSize, 0); } -#pragma pop /* 80020F48-80020F7C 0034+00 s=1 e=1 z=0 None .text fpcDtTg_ToDeleteQ__FP16delete_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDtTg_ToDeleteQ(delete_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_delete_tag/fpcDtTg_ToDeleteQ__FP16delete_tag_class.s" +void fpcDtTg_ToDeleteQ(delete_tag_class* pTag) { + pTag->mTimer = 1; + cTg_Addition(&g_fpcDtTg_Queue, &pTag->mBase); } -#pragma pop /* 80020F7C-80020F9C 0020+00 s=1 e=0 z=0 None .text fpcDtTg_DeleteQTo__FP16delete_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcDtTg_DeleteQTo(delete_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_delete_tag/fpcDtTg_DeleteQTo__FP16delete_tag_class.s" +void fpcDtTg_DeleteQTo(delete_tag_class* pTag) { + cTg_SingleCut(&pTag->mBase); } -#pragma pop /* 80020F9C-8002101C 0080+00 s=0 e=1 z=0 None .text fpcDtTg_Do__FP16delete_tag_classPFPv_i */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDtTg_Do(delete_tag_class* param_0, int (*)(void*)) { - nofralloc -#include "asm/f_pc/f_pc_delete_tag/fpcDtTg_Do__FP16delete_tag_classPFPv_i.s" +s32 fpcDtTg_Do(delete_tag_class* pTag, delete_tag_func pFunc) { + if (pTag->mTimer <= 0) { + s32 ret; + fpcDtTg_DeleteQTo(pTag); + ret = pFunc(pTag->mBase.mpTagData); + if (ret == 0) { + fpcDtTg_ToDeleteQ(pTag); + return 0; + } else { + return 1; + } + } else { + pTag->mTimer--; + return 0; + } } -#pragma pop /* 8002101C-80021040 0024+00 s=0 e=1 z=0 None .text fpcDtTg_Init__FP16delete_tag_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDtTg_Init(delete_tag_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_delete_tag/fpcDtTg_Init__FP16delete_tag_classPv.s" +s32 fpcDtTg_Init(delete_tag_class* pTag, void* pUserData) { + cTg_Create(&pTag->mBase, pUserData); + return 1; } -#pragma pop diff --git a/src/f_pc/f_pc_deletor.cpp b/src/f_pc/f_pc_deletor.cpp index 65be2bf609..c4b53fe84c 100644 --- a/src/f_pc/f_pc_deletor.cpp +++ b/src/f_pc/f_pc_deletor.cpp @@ -6,162 +6,113 @@ #include "f_pc/f_pc_deletor.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct process_priority_class {}; - -struct process_node_class {}; - -struct node_list_class {}; - -struct node_class {}; - -struct line_tag {}; - -struct layer_class {}; - -struct delete_tag_class {}; - -struct create_tag_class {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcDt_IsComplete(); -static void fpcDt_deleteMethod(base_process_class*); -void fpcDt_Handler(); -static void fpcDt_ToQueue(base_process_class*); -static void fpcDt_ToDeleteQ(base_process_class*); -void fpcDt_Delete(void*); - -extern "C" void fpcDt_IsComplete__Fv(); -extern "C" static void fpcDt_deleteMethod__FP18base_process_class(); -extern "C" void fpcDt_Handler__Fv(); -extern "C" static void fpcDt_ToQueue__FP18base_process_class(); -extern "C" static void fpcDt_ToDeleteQ__FP18base_process_class(); -extern "C" void fpcDt_Delete__FPv(); - -// -// External References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcBs_IsDelete(base_process_class*); -void fpcBs_Delete(base_process_class*); -void fpcCt_IsDoing(base_process_class*); -void fpcCt_Abort(base_process_class*); -void fpcDtTg_IsEmpty(); -void fpcDtTg_ToDeleteQ(delete_tag_class*); -void fpcDtTg_Do(delete_tag_class*, int (*)(void*)); -void fpcEx_IsExist(unsigned int); -void fpcEx_ExecuteQTo(base_process_class*); -void fpcLy_DeletingMesg(layer_class*); -void fpcLy_DeletedMesg(layer_class*); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_Cancel(layer_class*); -void fpcLyIt_OnlyHereLY(layer_class*, int (*)(void*, void*), void*); -void fpcLd_Free(s16); -void fpcNd_IsDeleteTiming(process_node_class*); -void fpcPi_IsInQueue(process_priority_class*); -void fpcPi_Delete(process_priority_class*); -void fpcLnTg_QueueTo(line_tag*); -void cLsIt_Method(node_list_class*, int (*)(node_class*, void*), void*); -void cTg_IsUse(create_tag_class*); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcBs_IsDelete__FP18base_process_class(); -extern "C" void fpcBs_Delete__FP18base_process_class(); -extern "C" void fpcCt_IsDoing__FP18base_process_class(); -extern "C" void fpcCt_Abort__FP18base_process_class(); -extern "C" void fpcDtTg_IsEmpty__Fv(); -extern "C" void fpcDtTg_ToDeleteQ__FP16delete_tag_class(); -extern "C" void fpcDtTg_Do__FP16delete_tag_classPFPv_i(); -extern "C" void fpcEx_IsExist__FUi(); -extern "C" void fpcEx_ExecuteQTo__FP18base_process_class(); -extern "C" void fpcLy_DeletingMesg__FP11layer_class(); -extern "C" void fpcLy_DeletedMesg__FP11layer_class(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_Cancel__FP11layer_class(); -extern "C" void fpcLyIt_OnlyHereLY__FP11layer_classPFPvPv_iPv(); -extern "C" void fpcLd_Free__Fs(); -extern "C" void fpcNd_IsDeleteTiming__FP18process_node_class(); -extern "C" void fpcPi_IsInQueue__FP22process_priority_class(); -extern "C" void fpcPi_Delete__FP22process_priority_class(); -extern "C" void fpcLnTg_QueueTo__FP8line_tag(); -extern "C" void cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv(); -extern "C" void cTg_IsUse__FP16create_tag_class(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_29(); -extern "C" extern u8 g_fpcDtTg_Queue[12 + 4 /* padding */]; -extern "C" extern u8 g_fpcNd_type[4 + 4 /* padding */]; +#include "f_pc/f_pc_load.h" +#include "SSystem/SComponent/c_list_iter.h" +#include "f_pc/f_pc_node.h" +#include "f_pc/f_pc_layer_iter.h" +#include "f_pc/f_pc_executor.h" +#include "f_pc/f_pc_creator.h" // // Declarations: // /* 80021040-80021060 0020+00 s=0 e=1 z=0 None .text fpcDt_IsComplete__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDt_IsComplete() { - nofralloc -#include "asm/f_pc/f_pc_deletor/fpcDt_IsComplete__Fv.s" +BOOL fpcDt_IsComplete() { + return fpcDtTg_IsEmpty(); } -#pragma pop /* 80021060-800210D4 0074+00 s=1 e=0 z=0 None .text fpcDt_deleteMethod__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcDt_deleteMethod(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_deletor/fpcDt_deleteMethod__FP18base_process_class.s" +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; + } } -#pragma pop /* 800210D4-8002110C 0038+00 s=0 e=1 z=0 None .text fpcDt_Handler__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDt_Handler() { - nofralloc -#include "asm/f_pc/f_pc_deletor/fpcDt_Handler__Fv.s" +void fpcDt_Handler(void) { + cLsIt_Method(&g_fpcDtTg_Queue, (cNdIt_MethodFunc)fpcDtTg_Do, fpcDt_deleteMethod); } -#pragma pop /* 8002110C-80021188 007C+00 s=1 e=0 z=0 None .text fpcDt_ToQueue__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcDt_ToQueue(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_deletor/fpcDt_ToQueue__FP18base_process_class.s" +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; + } } -#pragma pop /* 80021188-800212A4 011C+00 s=1 e=0 z=0 None .text fpcDt_ToDeleteQ__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcDt_ToDeleteQ(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_deletor/fpcDt_ToDeleteQ__FP18base_process_class.s" +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(g_fpcNd_type, 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, (fpcLyIt_OnlyHereFunc)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; + } + } + } } -#pragma pop /* 800212A4-80021308 0064+00 s=0 e=3 z=0 None .text fpcDt_Delete__FPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDt_Delete(void* param_0) { - nofralloc -#include "asm/f_pc/f_pc_deletor/fpcDt_Delete__FPv.s" +s32 fpcDt_Delete(void* pProcV) { + base_process_class* pProc = static_cast(pProcV); + if (pProc != NULL) { + if (fpcCt_IsDoing(pProc) == 1) + return 0; + + if (pProc->mInitState == 3) + return 0; + + return fpcDt_ToDeleteQ(pProc); + } else { + return 1; + } } -#pragma pop diff --git a/src/f_pc/f_pc_draw.cpp b/src/f_pc/f_pc_draw.cpp index e4c12d6e90..2ce62954e9 100644 --- a/src/f_pc/f_pc_draw.cpp +++ b/src/f_pc/f_pc_draw.cpp @@ -6,66 +6,40 @@ #include "f_pc/f_pc_draw.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct layer_class {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcDw_Execute(base_process_class*); -void fpcDw_Handler(int (*)(int (*)(void*, void*)), int (*)(void*, void*)); - -extern "C" void fpcDw_Execute__FP18base_process_class(); -extern "C" void fpcDw_Handler__FPFPFPvPv_i_iPFPvPv_i(); - -// -// External References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_CurrentLayer(); -void fpcPause_IsEnable(void*, u8); -void cAPIGph_BeforeOfDraw(); -void cAPIGph_AfterOfDraw(); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" void fpcPause_IsEnable__FPvUc(); -extern "C" void cAPIGph_BeforeOfDraw__Fv(); -extern "C" void cAPIGph_AfterOfDraw__Fv(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_29(); -extern "C" extern u8 g_fpcLf_type[4 + 4 /* padding */]; +#include "SSystem/SComponent/c_API_graphic.h" +#include "f_pc/f_pc_pause.h" +#include "f_pc/f_pc_leaf.h" // // Declarations: // /* 80023954-800239F4 00A0+00 s=0 e=1 z=0 None .text fpcDw_Execute__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDw_Execute(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_draw/fpcDw_Execute__FP18base_process_class.s" +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(g_fpcLf_type, 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; + } } -#pragma pop /* 800239F4-80023A48 0054+00 s=0 e=2 z=10 None .text fpcDw_Handler__FPFPFPvPv_i_iPFPvPv_i */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDw_Handler(int (*)(int (*)(void*, void*)), int (*)(void*, void*)) { - nofralloc -#include "asm/f_pc/f_pc_draw/fpcDw_Handler__FPFPFPvPv_i_iPFPvPv_i.s" +s32 fpcDw_Handler(fpcDw_HandlerFuncFunc param_1, fpcDw_HandlerFunc param_2) { + s32 ret; + cAPIGph_BeforeOfDraw(); + ret = param_1(param_2); + cAPIGph_AfterOfDraw(); + return ret; } -#pragma pop diff --git a/src/f_pc/f_pc_draw_priority.cpp b/src/f_pc/f_pc_draw_priority.cpp index 29b7dde0bb..bd5085dfb2 100644 --- a/src/f_pc/f_pc_draw_priority.cpp +++ b/src/f_pc/f_pc_draw_priority.cpp @@ -7,58 +7,21 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct draw_priority_class {}; - -// -// Forward References: -// - -void fpcDwPi_Get(draw_priority_class const*); -static void fpcDwPi_Set(draw_priority_class*, s16); -void fpcDwPi_Init(draw_priority_class*, s16); - -extern "C" void fpcDwPi_Get__FPC19draw_priority_class(); -extern "C" static void fpcDwPi_Set__FP19draw_priority_classs(); -extern "C" void fpcDwPi_Init__FP19draw_priority_classs(); - -// -// External References: -// - // // Declarations: // /* 80021308-80021310 0008+00 s=0 e=1 z=0 None .text fpcDwPi_Get__FPC19draw_priority_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDwPi_Get(draw_priority_class const* param_0) { - nofralloc -#include "asm/f_pc/f_pc_draw_priority/fpcDwPi_Get__FPC19draw_priority_class.s" +s32 fpcDwPi_Get(const draw_priority_class* pDwPi) { + return pDwPi->mPriority; } -#pragma pop /* 80021310-80021318 0008+00 s=1 e=0 z=0 None .text fpcDwPi_Set__FP19draw_priority_classs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcDwPi_Set(draw_priority_class* param_0, s16 param_1) { - nofralloc -#include "asm/f_pc/f_pc_draw_priority/fpcDwPi_Set__FP19draw_priority_classs.s" +void fpcDwPi_Set(draw_priority_class* pDwPi, s16 p) { + pDwPi->mPriority = p; } -#pragma pop /* 80021318-80021338 0020+00 s=0 e=1 z=0 None .text fpcDwPi_Init__FP19draw_priority_classs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcDwPi_Init(draw_priority_class* param_0, s16 param_1) { - nofralloc -#include "asm/f_pc/f_pc_draw_priority/fpcDwPi_Init__FP19draw_priority_classs.s" +void fpcDwPi_Init(draw_priority_class* pDwPi, s16 p) { + fpcDwPi_Set(pDwPi, p); } -#pragma pop diff --git a/src/f_pc/f_pc_executor.cpp b/src/f_pc/f_pc_executor.cpp index d2257beb1c..f1a8c31869 100644 --- a/src/f_pc/f_pc_executor.cpp +++ b/src/f_pc/f_pc_executor.cpp @@ -6,154 +6,89 @@ #include "f_pc/f_pc_executor.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct line_tag {}; - -struct layer_management_tag_class {}; - -struct layer_class {}; - -struct create_tag_class {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcEx_Search(void* (*)(void*, void*), void*); -void fpcEx_SearchByID(unsigned int); -void fpcEx_IsExist(unsigned int); -void fpcEx_Execute(base_process_class*); -static void fpcEx_ToLineQ(base_process_class*); -void fpcEx_ExecuteQTo(base_process_class*); -void fpcEx_ToExecuteQ(base_process_class*); -void fpcEx_Handler(int (*)(void*, void*)); - -extern "C" void fpcEx_Search__FPFPvPv_PvPv(); -extern "C" void fpcEx_SearchByID__FUi(); -extern "C" void fpcEx_IsExist__FUi(); -extern "C" void fpcEx_Execute__FP18base_process_class(); -extern "C" static void fpcEx_ToLineQ__FP18base_process_class(); -extern "C" void fpcEx_ExecuteQTo__FP18base_process_class(); -extern "C" void fpcEx_ToExecuteQ__FP18base_process_class(); -extern "C" void fpcEx_Handler__FPFPvPv_i(); - -// -// External References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcBs_Execute(base_process_class*); -void fpcLyIt_OnlyHere(layer_class*, int (*)(void*, void*), void*); -void fpcLyIt_AllJudge(void* (*)(void*, void*), void*); -void fpcLyTg_ToQueue(layer_management_tag_class*, unsigned int, u16, u16); -void fpcLyTg_QueueTo(layer_management_tag_class*); -void fpcSch_JudgeByID(void*, void*); -void fpcLnTg_ToQueue(line_tag*, int); -void fpcLnIt_Queue(int (*)(void*, void*)); -void fpcPause_IsEnable(void*, u8); -void cTg_IsUse(create_tag_class*); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcBs_Execute__FP18base_process_class(); -extern "C" void fpcLyIt_OnlyHere__FP11layer_classPFPvPv_iPv(); -extern "C" void fpcLyIt_AllJudge__FPFPvPv_PvPv(); -extern "C" void fpcLyTg_ToQueue__FP26layer_management_tag_classUiUsUs(); -extern "C" void fpcLyTg_QueueTo__FP26layer_management_tag_class(); -extern "C" void fpcSch_JudgeByID__FPvPv(); -extern "C" void fpcLnTg_ToQueue__FP8line_tagi(); -extern "C" void fpcLnIt_Queue__FPFPvPv_i(); -extern "C" void fpcPause_IsEnable__FPvUc(); -extern "C" void cTg_IsUse__FP16create_tag_class(); -extern "C" extern u8 g_fpcNd_type[4 + 4 /* padding */]; +#include "f_pc/f_pc_searcher.h" +#include "f_pc/f_pc_node.h" +#include "f_pc/f_pc_pause.h" // // Declarations: // /* 80021338-80021358 0020+00 s=1 e=9 z=291 None .text fpcEx_Search__FPFPvPv_PvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_Search(void* (*)(void*, void*), void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_Search__FPFPvPv_PvPv.s" +base_process_class* fpcEx_Search(fpcLyIt_JudgeFunc pFunc, void* pUserData) { + return (base_process_class*)fpcLyIt_AllJudge(pFunc, pUserData); } -#pragma pop /* 80021358-8002139C 0044+00 s=1 e=5 z=30 None .text fpcEx_SearchByID__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_SearchByID(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_SearchByID__FUi.s" +base_process_class* fpcEx_SearchByID(unsigned int id) { + if (id + 2 <= 1) + return NULL; + + return fpcEx_Search(fpcSch_JudgeByID, &id); } -#pragma pop /* 8002139C-800213C4 0028+00 s=0 e=7 z=42 None .text fpcEx_IsExist__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_IsExist(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_IsExist__FUi.s" +BOOL fpcEx_IsExist(unsigned int id) { + return fpcEx_SearchByID(id) != NULL ? 1 : 0; } -#pragma pop /* 800213C4-80021418 0054+00 s=0 e=1 z=0 None .text fpcEx_Execute__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_Execute(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_Execute__FP18base_process_class.s" +s32 fpcEx_Execute(base_process_class* pProc) { + if (pProc->mInitState != 2 || fpcPause_IsEnable(pProc, 1) == 1) + return 0; + return fpcBs_Execute(pProc); } -#pragma pop /* 80021418-800214C4 00AC+00 s=1 e=0 z=0 None .text fpcEx_ToLineQ__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcEx_ToLineQ(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_ToLineQ__FP18base_process_class.s" +s32 fpcEx_ToLineQ(base_process_class* pProc) { + layer_class* pLayer = pProc->mLyTg.mpLayer; + base_process_class* pLayerPcNode = &pLayer->mpPcNode->mBase; + + 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; + } + + pProc->mInitState = 2; + if (fpcBs_Is_JustOfType(g_fpcNd_type, pProc->mSubType)) { + process_node_class* pNode = (process_node_class*)pProc; + fpcLyIt_OnlyHere(&pNode->mLayer, (fpcLyIt_OnlyHereFunc)fpcEx_ToLineQ, pNode); + } + + return 1; + } + + return 0; } -#pragma pop /* 800214C4-80021510 004C+00 s=0 e=1 z=0 None .text fpcEx_ExecuteQTo__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_ExecuteQTo(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_ExecuteQTo__FP18base_process_class.s" +s32 fpcEx_ExecuteQTo(base_process_class* pProc) { + s32 ret = fpcLyTg_QueueTo(&pProc->mLyTg); + if (ret == 1) { + pProc->mInitState = 3; + return 1; + } else { + return 0; + } } -#pragma pop /* 80021510-80021568 0058+00 s=0 e=1 z=0 None .text fpcEx_ToExecuteQ__FP18base_process_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_ToExecuteQ(base_process_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_ToExecuteQ__FP18base_process_class.s" +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); + return 1; + } else { + return 0; + } } -#pragma pop /* 80021568-80021588 0020+00 s=0 e=1 z=0 None .text fpcEx_Handler__FPFPvPv_i */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcEx_Handler(int (*)(void*, void*)) { - nofralloc -#include "asm/f_pc/f_pc_executor/fpcEx_Handler__FPFPvPv_i.s" +void fpcEx_Handler(fpcLnIt_QueueFunc pFunc) { + fpcLnIt_Queue(pFunc); } -#pragma pop diff --git a/src/f_pc/f_pc_fstcreate_req.cpp b/src/f_pc/f_pc_fstcreate_req.cpp index b5e36b5007..fdfa83bc1f 100644 --- a/src/f_pc/f_pc_fstcreate_req.cpp +++ b/src/f_pc/f_pc_fstcreate_req.cpp @@ -6,93 +6,63 @@ #include "f_pc/f_pc_fstcreate_req.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct layer_class {}; - -struct fast_create_request {}; - -struct create_request_method_class {}; - -struct create_request {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcFCtRq_Do(fast_create_request*); -static bool fpcFCtRq_Delete(fast_create_request*); -void fpcFCtRq_Request(layer_class*, s16, int (*)(void*, void*), void*, void*); - -extern "C" void fpcFCtRq_Do__FP19fast_create_request(); -extern "C" static bool fpcFCtRq_Delete__FP19fast_create_request(); -extern "C" void fpcFCtRq_Request__FP11layer_classsPFPvPv_iPvPv(); - -// -// External References: -// - -void fpcBs_MakeOfId(); -void fpcBs_Create(s16, unsigned int, void*); -void fpcBs_SubCreate(base_process_class*); -void fpcCtRq_Cancel(create_request*); -void fpcCtRq_Create(layer_class*, u32, create_request_method_class*); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLd_Use(s16); - -extern "C" void fpcBs_MakeOfId__Fv(); -extern "C" void fpcBs_Create__FsUiPv(); -extern "C" void fpcBs_SubCreate__FP18base_process_class(); -extern "C" void fpcCtRq_Cancel__FP14create_request(); -extern "C" void fpcCtRq_Create__FP11layer_classUlP27create_request_method_class(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLd_Use__Fs(); -extern "C" void _savegpr_26(); -extern "C" void _restgpr_26(); +#include "f_pc/f_pc_load.h" // // Declarations: // /* 80023A48-80023A98 0050+00 s=1 e=3 z=52 None .text fpcFCtRq_Do__FP19fast_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcFCtRq_Do(fast_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_fstcreate_req/fpcFCtRq_Do__FP19fast_create_request.s" +s32 fpcFCtRq_Do(fast_create_request* pFstCreateReq) { + if (pFstCreateReq->mpFastCreateFunc != NULL && + pFstCreateReq->mpFastCreateFunc(pFstCreateReq->mBase.mpRes, + pFstCreateReq->mpFastCreateData) == 0) { + return 3; + } else { + return 4; + } } -#pragma pop /* 80023A98-80023AA0 0008+00 s=1 e=0 z=0 None .text fpcFCtRq_Delete__FP19fast_create_request */ -static bool fpcFCtRq_Delete(fast_create_request* param_0) { - return true; +s32 fpcFCtRq_Delete(fast_create_request* pFstCreateReq) { + return 1; } /* ############################################################################################## */ /* 803A3AE0-803A3AF0 000C+04 s=1 e=0 z=0 None .data submethod$2214 */ -SECTION_DATA static void* submethod[3 + 1 /* padding */] = { - (void*)fpcFCtRq_Do__FP19fast_create_request, - (void*)NULL, - (void*)fpcFCtRq_Delete__FP19fast_create_request, - /* padding */ +create_request_method_class submethod = { + (cPhs__Handler)fpcFCtRq_Do, NULL, + (process_method_func)fpcFCtRq_Delete }; /* 80023AA0-80023B70 00D0+00 s=0 e=3 z=43 None .text * fpcFCtRq_Request__FP11layer_classsPFPvPv_iPvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcFCtRq_Request(layer_class* param_0, s16 param_1, int (*)(void*, void*), void* param_3, - void* param_4) { - nofralloc -#include "asm/f_pc/f_pc_fstcreate_req/fpcFCtRq_Request__FP11layer_classsPFPvPv_iPvPv.s" +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, &submethod); + 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; + } } -#pragma pop diff --git a/src/f_pc/f_pc_layer.cpp b/src/f_pc/f_pc_layer.cpp index bdbc974708..0d94815a3e 100644 --- a/src/f_pc/f_pc_layer.cpp +++ b/src/f_pc/f_pc_layer.cpp @@ -6,351 +6,192 @@ #include "f_pc/f_pc_layer.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct process_method_tag_class {}; - -struct node_lists_tree_class {}; - -struct node_list_class {}; - -struct node_class {}; - -struct layer_class {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcLy_CancelQTo(process_method_tag_class*); -void fpcLy_ToCancelQ(layer_class*, process_method_tag_class*); -static void fpcLy_CancelMethod(process_method_tag_class*); -void fpcLy_IntoQueue(layer_class*, int, create_tag_class*, int); -void fpcLy_ToQueue(layer_class*, int, create_tag_class*); -void fpcLy_QueueTo(layer_class*, create_tag_class*); -void fpcLy_IsDeletingMesg(layer_class*); -void fpcLy_DeletingMesg(layer_class*); -void fpcLy_DeletedMesg(layer_class*); -void fpcLy_IsCreatingMesg(layer_class*); -void fpcLy_CreatingMesg(layer_class*); -void fpcLy_CreatedMesg(layer_class*); -void fpcLy_RootLayer(); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_CurrentLayer(); -static void fpcLy_Search(unsigned int); -void fpcLy_Layer(unsigned int); -static void fpcLy_Regist(layer_class*); -void fpcLy_Delete(layer_class*); -void fpcLy_Cancel(layer_class*); -void fpcLy_Create(layer_class*, void*, node_list_class*, int); - -extern "C" void fpcLy_CancelQTo__FP24process_method_tag_class(); -extern "C" void fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class(); -extern "C" static void fpcLy_CancelMethod__FP24process_method_tag_class(); -extern "C" void fpcLy_IntoQueue__FP11layer_classiP16create_tag_classi(); -extern "C" void fpcLy_ToQueue__FP11layer_classiP16create_tag_class(); -extern "C" void fpcLy_QueueTo__FP11layer_classP16create_tag_class(); -extern "C" void fpcLy_IsDeletingMesg__FP11layer_class(); -extern "C" void fpcLy_DeletingMesg__FP11layer_class(); -extern "C" void fpcLy_DeletedMesg__FP11layer_class(); -extern "C" void fpcLy_IsCreatingMesg__FP11layer_class(); -extern "C" void fpcLy_CreatingMesg__FP11layer_class(); -extern "C" void fpcLy_CreatedMesg__FP11layer_class(); -extern "C" void fpcLy_RootLayer__Fv(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" static void fpcLy_Search__FUi(); -extern "C" void fpcLy_Layer__FUi(); -extern "C" static void fpcLy_Regist__FP11layer_class(); -extern "C" void fpcLy_Delete__FP11layer_class(); -extern "C" void fpcLy_Cancel__FP11layer_class(); -extern "C" void fpcLy_Create__FP11layer_classPvP15node_list_classi(); - -// -// External References: -// - -void fpcMtdIt_Method(node_list_class*, int (*)(void*)); -void fpcMtdTg_Do(process_method_tag_class*); -void fpcMtdTg_ToMethodQ(node_list_class*, process_method_tag_class*); -void fpcMtdTg_MethodQTo(process_method_tag_class*); -void cLs_SingleCut(node_class*); -void cLs_Addition(node_list_class*, node_class*); -void cLs_Create(node_list_class*); -void cNd_Create(node_class*, void*); -void cTr_Create(node_lists_tree_class*, node_list_class*, int); -void cTg_SingleCutFromTree(create_tag_class*); -void cTg_AdditionToTree(node_lists_tree_class*, int, create_tag_class*); -void cTg_InsertToTree(node_lists_tree_class*, int, create_tag_class*, int); - -extern "C" void fpcMtdIt_Method__FP15node_list_classPFPv_i(); -extern "C" void fpcMtdTg_Do__FP24process_method_tag_class(); -extern "C" void fpcMtdTg_ToMethodQ__FP15node_list_classP24process_method_tag_class(); -extern "C" void fpcMtdTg_MethodQTo__FP24process_method_tag_class(); -extern "C" void cLs_SingleCut__FP10node_class(); -extern "C" void cLs_Addition__FP15node_list_classP10node_class(); -extern "C" void cLs_Create__FP15node_list_class(); -extern "C" void cNd_Create__FP10node_classPv(); -extern "C" void cTr_Create__FP21node_lists_tree_classP15node_list_classi(); -extern "C" void cTg_SingleCutFromTree__FP16create_tag_class(); -extern "C" void cTg_AdditionToTree__FP21node_lists_tree_classiP16create_tag_class(); -extern "C" void cTg_InsertToTree__FP21node_lists_tree_classiP16create_tag_classi(); -extern "C" void _savegpr_28(); -extern "C" void _restgpr_28(); +#include "f_pc/f_pc_method.h" +#include "f_pc/f_pc_method_tag.h" +#include "f_pc/f_pc_method_iter.h" +#include "f_pc/f_pc_layer.h" // // Declarations: // +// hack to make functions that return comparisons as int match +extern int __cntlzw(unsigned int); +inline BOOL checkEqual(s32 a, s32 b) { + return (u32)__cntlzw(a - b) >> 5; +} + /* 80021588-800215A8 0020+00 s=0 e=4 z=0 None .text fpcLy_CancelQTo__FP24process_method_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_CancelQTo(process_method_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_CancelQTo__FP24process_method_tag_class.s" +void fpcLy_CancelQTo(process_method_tag_class* pMthd) { + fpcMtdTg_MethodQTo(pMthd); } -#pragma pop /* 800215A8-800215CC 0024+00 s=0 e=3 z=0 None .text * fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_ToCancelQ(layer_class* param_0, process_method_tag_class* param_1) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class.s" +s32 fpcLy_ToCancelQ(layer_class* pLayer, process_method_tag_class* pMthd) { + return fpcMtdTg_ToMethodQ(&pLayer->mCancelList, pMthd); } -#pragma pop /* 800215CC-800215F8 002C+00 s=1 e=0 z=0 None .text * fpcLy_CancelMethod__FP24process_method_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLy_CancelMethod(process_method_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_CancelMethod__FP24process_method_tag_class.s" +BOOL fpcLy_CancelMethod(process_method_tag_class* pLayer) { + return checkEqual(1, fpcMtdTg_Do(pLayer)); } -#pragma pop /* 800215F8-8002161C 0024+00 s=0 e=1 z=0 None .text * fpcLy_IntoQueue__FP11layer_classiP16create_tag_classi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_IntoQueue(layer_class* param_0, int param_1, create_tag_class* param_2, - int param_3) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_IntoQueue__FP11layer_classiP16create_tag_classi.s" +s32 fpcLy_IntoQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag, int idx) { + return cTg_InsertToTree(&pLayer->mNodeListTree, treeListIdx, pTag, idx); } -#pragma pop /* 8002161C-80021640 0024+00 s=0 e=1 z=0 None .text * fpcLy_ToQueue__FP11layer_classiP16create_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_ToQueue(layer_class* param_0, int param_1, create_tag_class* param_2) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_ToQueue__FP11layer_classiP16create_tag_class.s" +s32 fpcLy_ToQueue(layer_class* pLayer, int treeListIdx, create_tag_class* pTag) { + return cTg_AdditionToTree(&pLayer->mNodeListTree, treeListIdx, pTag); } -#pragma pop /* 80021640-80021664 0024+00 s=0 e=1 z=0 None .text * fpcLy_QueueTo__FP11layer_classP16create_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_QueueTo(layer_class* param_0, create_tag_class* param_1) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_QueueTo__FP11layer_classP16create_tag_class.s" +s32 fpcLy_QueueTo(layer_class* pLayer, create_tag_class* pTag) { + return cTg_SingleCutFromTree(pTag); } -#pragma pop /* 80021664-80021678 0014+00 s=0 e=1 z=0 None .text fpcLy_IsDeletingMesg__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_IsDeletingMesg(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_IsDeletingMesg__FP11layer_class.s" +BOOL fpcLy_IsDeletingMesg(layer_class* pLayer) { + return pLayer->counts.mDeletingCount > 0; } -#pragma pop /* 80021678-80021688 0010+00 s=0 e=1 z=0 None .text fpcLy_DeletingMesg__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_DeletingMesg(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_DeletingMesg__FP11layer_class.s" +void fpcLy_DeletingMesg(layer_class* pLayer) { + pLayer->counts.mDeletingCount++; } -#pragma pop /* 80021688-800216A0 0018+00 s=0 e=1 z=0 None .text fpcLy_DeletedMesg__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_DeletedMesg(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_DeletedMesg__FP11layer_class.s" +void fpcLy_DeletedMesg(layer_class* pLayer) { + if (pLayer->counts.mDeletingCount > 0) { + pLayer->counts.mDeletingCount--; + } } -#pragma pop /* 800216A0-800216B4 0014+00 s=0 e=2 z=0 None .text fpcLy_IsCreatingMesg__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_IsCreatingMesg(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_IsCreatingMesg__FP11layer_class.s" +BOOL fpcLy_IsCreatingMesg(layer_class* pLayer) { + return pLayer->counts.mCreatingCount > 0; } -#pragma pop /* 800216B4-800216C4 0010+00 s=0 e=2 z=0 None .text fpcLy_CreatingMesg__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_CreatingMesg(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_CreatingMesg__FP11layer_class.s" +void fpcLy_CreatingMesg(layer_class* pLayer) { + pLayer->counts.mCreatingCount++; } -#pragma pop /* 800216C4-800216DC 0018+00 s=0 e=2 z=0 None .text fpcLy_CreatedMesg__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_CreatedMesg(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_CreatedMesg__FP11layer_class.s" +void fpcLy_CreatedMesg(layer_class* pLayer) { + if (pLayer->counts.mCreatingCount > 0) { + pLayer->counts.mCreatingCount--; + } } -#pragma pop /* ############################################################################################## */ /* 803A39B0-803A39DC 002C+00 s=2 e=0 z=0 None .data l_fpcLy_Crear */ -SECTION_DATA static u8 l_fpcLy_Crear[44] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, - 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +layer_class l_fpcLy_Crear = { + NULL, NULL, 0, + 0xFFFFFFFF, + NULL, 0, + NULL, + NULL, NULL, 0, + 0, 0, }; /* 803A39DC-803A39E8 000C+00 s=3 e=0 z=0 None .data l_fpcLy_LayerList */ -SECTION_DATA static u8 l_fpcLy_LayerList[12] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +node_list_class l_fpcLy_LayerList = { + NULL, + NULL, + 0, }; /* 800216DC-800216EC 0010+00 s=2 e=3 z=0 None .text fpcLy_RootLayer__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_RootLayer() { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_RootLayer__Fv.s" +layer_class* fpcLy_RootLayer(void) { + return (layer_class*)l_fpcLy_LayerList.mpHead; } -#pragma pop /* ############################################################################################## */ /* 80450D18-80450D1C 0004+00 s=2 e=0 z=0 None .sbss l_fpcLy_CurrLayer_p */ -static u8 l_fpcLy_CurrLayer_p[4]; +static layer_class* l_fpcLy_CurrLayer_p; /* 800216EC-800216F4 0008+00 s=1 e=13 z=0 None .text fpcLy_SetCurrentLayer__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_SetCurrentLayer(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_SetCurrentLayer__FP11layer_class.s" +void fpcLy_SetCurrentLayer(layer_class* pLayer) { + l_fpcLy_CurrLayer_p = pLayer; } -#pragma pop /* 800216F4-800216FC 0008+00 s=1 e=21 z=0 None .text fpcLy_CurrentLayer__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_CurrentLayer() { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_CurrentLayer__Fv.s" +layer_class* fpcLy_CurrentLayer(void) { + return l_fpcLy_CurrLayer_p; } -#pragma pop /* 800216FC-8002174C 0050+00 s=1 e=0 z=0 None .text fpcLy_Search__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLy_Search(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_Search__FUi.s" +layer_class* fpcLy_Search(unsigned int id) { + layer_class* iVar1 = fpcLy_RootLayer(); + while (iVar1 != NULL) { + if (iVar1->mLayerID == id) { + return iVar1; + } + iVar1 = (layer_class*)iVar1->mNode.mpNextNode; + } + return NULL; } -#pragma pop /* 8002174C-800217BC 0070+00 s=0 e=5 z=0 None .text fpcLy_Layer__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_Layer(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_Layer__FUi.s" +layer_class* fpcLy_Layer(unsigned int id) { + if (id == 0 || fpcLy_RootLayer()->mLayerID == id) { + return fpcLy_RootLayer(); + } else if (id == ~2 || fpcLy_CurrentLayer()->mLayerID == id) { + return fpcLy_CurrentLayer(); + } else { + return fpcLy_Search(id); + } } -#pragma pop /* 800217BC-800217E8 002C+00 s=1 e=0 z=0 None .text fpcLy_Regist__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLy_Regist(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_Regist__FP11layer_class.s" +void fpcLy_Regist(layer_class* pLayer) { + cLs_Addition(&l_fpcLy_LayerList, (node_class*)pLayer); } -#pragma pop /* 800217E8-8002189C 00B4+00 s=0 e=1 z=0 None .text fpcLy_Delete__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_Delete(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_Delete__FP11layer_class.s" +s32 fpcLy_Delete(layer_class* pLayer) { + if (pLayer->mNodeListTree.mpLists->mSize == 0 && pLayer->mCancelList.mSize == 0) { + cLs_SingleCut((node_class*)pLayer); + *pLayer = l_fpcLy_Crear; + return 1; + } else { + return 0; + } } -#pragma pop /* 8002189C-800218C8 002C+00 s=0 e=1 z=0 None .text fpcLy_Cancel__FP11layer_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_Cancel(layer_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_Cancel__FP11layer_class.s" +void fpcLy_Cancel(layer_class* pLayer) { + fpcMtdIt_Method(&pLayer->mCancelList, (fpcMtdIt_MethodFunc)fpcLy_CancelMethod); } -#pragma pop - -/* ############################################################################################## */ -/* 80450D1C-80450D20 0004+00 s=1 e=0 z=0 None .sbss IsInitOfLayerList$2308 */ -static u8 IsInitOfLayerList[4]; - -/* 80450D20-80450D24 0004+00 s=1 e=0 z=0 None .sbss None */ -static u8 data_80450D20[4]; - -/* 80450D24-80450D28 0004+00 s=1 e=0 z=0 None .sbss layer_id$2311 */ -static u8 layer_id[4]; - -/* 80450D28-80450D30 0008+00 s=1 e=0 z=0 None .sbss None */ -static u8 data_80450D28[8]; /* 800218C8-80021A00 0138+00 s=0 e=2 z=0 None .text * fpcLy_Create__FP11layer_classPvP15node_list_classi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLy_Create(layer_class* param_0, void* param_1, node_list_class* param_2, int param_3) { - nofralloc -#include "asm/f_pc/f_pc_layer/fpcLy_Create__FP11layer_classPvP15node_list_classi.s" +void fpcLy_Create(layer_class* pLayer, void* pPcNode, node_list_class* pLists, int listNum) { + void* pvVar1; + s32 iVar2; + + static int IsInitOfLayerList = 1; + static int layer_id = 0; + *pLayer = l_fpcLy_Crear; + cNd_Create((node_class*)pLayer, NULL); + pLayer->mLayerID = layer_id++; + pLayer->mpPcNode = static_cast(pPcNode); + if (IsInitOfLayerList == 0x1) { + IsInitOfLayerList = 0x0; + cLs_Create(&l_fpcLy_LayerList); + fpcLy_SetCurrentLayer(pLayer); + } + (pLayer->mNodeListTree).mpLists = pLists; + (pLayer->mNodeListTree).mNumLists = listNum; + cTr_Create(&pLayer->mNodeListTree, (pLayer->mNodeListTree).mpLists, + (pLayer->mNodeListTree).mNumLists); + fpcLy_Regist(pLayer); } -#pragma pop diff --git a/src/f_pc/f_pc_layer_iter.cpp b/src/f_pc/f_pc_layer_iter.cpp index 04da60eda5..1ddc32409d 100644 --- a/src/f_pc/f_pc_layer_iter.cpp +++ b/src/f_pc/f_pc_layer_iter.cpp @@ -6,58 +6,9 @@ #include "f_pc/f_pc_layer_iter.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct node_lists_tree_class {}; - -struct node_class {}; - -struct method_filter {}; - -struct layer_class {}; - -struct judge_filter {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcLyIt_OnlyHere(layer_class*, int (*)(void*, void*), void*); -void fpcLyIt_OnlyHereLY(layer_class*, int (*)(void*, void*), void*); -void fpcLyIt_Judge(layer_class*, void* (*)(void*, void*), void*); -void fpcLyIt_AllJudge(void* (*)(void*, void*), void*); - -extern "C" void fpcLyIt_OnlyHere__FP11layer_classPFPvPv_iPv(); -extern "C" void fpcLyIt_OnlyHereLY__FP11layer_classPFPvPv_iPv(); -extern "C" void fpcLyIt_Judge__FP11layer_classPFPvPv_PvPv(); -extern "C" void fpcLyIt_AllJudge__FPFPvPv_PvPv(); - -// -// External References: -// - -void fpcLy_RootLayer(); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_CurrentLayer(); -void cTrIt_Method(node_lists_tree_class*, int (*)(node_class*, void*), void*); -void cTrIt_Judge(node_lists_tree_class*, void* (*)(node_class*, void*), void*); -void cTgIt_MethodCall(create_tag_class*, method_filter*); -void cTgIt_JudgeFilter(create_tag_class*, judge_filter*); - -extern "C" void fpcLy_RootLayer__Fv(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" void cTrIt_Method__FP21node_lists_tree_classPFP10node_classPv_iPv(); -extern "C" void cTrIt_Judge__FP21node_lists_tree_classPFP10node_classPv_PvPv(); -extern "C" void cTgIt_MethodCall__FP16create_tag_classP13method_filter(); -extern "C" void cTgIt_JudgeFilter__FP16create_tag_classP12judge_filter(); -extern "C" void _savegpr_28(); -extern "C" void _restgpr_28(); +#include "SSystem/SComponent/c_tree_iter.h" +#include "SSystem/SComponent/c_node_iter.h" +#include "SSystem/SComponent/c_tag_iter.h" // // Declarations: @@ -65,43 +16,48 @@ extern "C" void _restgpr_28(); /* 80021B88-80021BC0 0038+00 s=1 e=4 z=0 None .text fpcLyIt_OnlyHere__FP11layer_classPFPvPv_iPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyIt_OnlyHere(layer_class* param_0, int (*)(void*, void*), void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_layer_iter/fpcLyIt_OnlyHere__FP11layer_classPFPvPv_iPv.s" +s32 fpcLyIt_OnlyHere(layer_class* pLayer, fpcLyIt_OnlyHereFunc pFunc, void* pUserData) { + layer_iter lIter; + lIter.mpFunc = pFunc; + lIter.mpUserData = pUserData; + return cTrIt_Method(&pLayer->mNodeListTree, (cNdIt_MethodFunc)cTgIt_MethodCall, &lIter); } -#pragma pop /* 80021BC0-80021C28 0068+00 s=0 e=1 z=0 None .text fpcLyIt_OnlyHereLY__FP11layer_classPFPvPv_iPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyIt_OnlyHereLY(layer_class* param_0, int (*)(void*, void*), void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_layer_iter/fpcLyIt_OnlyHereLY__FP11layer_classPFPvPv_iPv.s" +s32 fpcLyIt_OnlyHereLY(layer_class* pLayer, fpcLyIt_OnlyHereFunc pFunc, void* pUserData) { + s32 result; + layer_class* currentLayer = fpcLy_CurrentLayer(); + fpcLy_SetCurrentLayer(pLayer); + result = fpcLyIt_OnlyHere(pLayer, pFunc, pUserData); + fpcLy_SetCurrentLayer(currentLayer); + return result; } -#pragma pop /* 80021C28-80021C60 0038+00 s=0 e=3 z=0 None .text fpcLyIt_Judge__FP11layer_classPFPvPv_PvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyIt_Judge(layer_class* param_0, void* (*)(void*, void*), void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_layer_iter/fpcLyIt_Judge__FP11layer_classPFPvPv_PvPv.s" +void* fpcLyIt_Judge(layer_class* pLayer, fpcLyIt_JudgeFunc pFunc, void* pUserData) { + layer_iter lIter; + lIter.mpFunc = pFunc; + lIter.mpUserData = pUserData; + return cTrIt_Judge(&pLayer->mNodeListTree, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &lIter); } -#pragma pop /* 80021C60-80021CD4 0074+00 s=0 e=1 z=4 None .text fpcLyIt_AllJudge__FPFPvPv_PvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyIt_AllJudge(void* (*)(void*, void*), void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_layer_iter/fpcLyIt_AllJudge__FPFPvPv_PvPv.s" +void* fpcLyIt_AllJudge(fpcLyIt_JudgeFunc pFunc, void* pUserData) { + layer_iter lIter; + layer_class* current; + lIter.mpFunc = pFunc; + lIter.mpUserData = pUserData; + + current = fpcLy_RootLayer(); + while (current != NULL) { + void* result = + cTrIt_Judge(¤t->mNodeListTree, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &lIter); + if (result != NULL) { + return result; + } + current = (layer_class*)current->mNode.mpNextNode; + } + return NULL; } -#pragma pop diff --git a/src/f_pc/f_pc_layer_tag.cpp b/src/f_pc/f_pc_layer_tag.cpp index 643afde3b9..d362609bcb 100644 --- a/src/f_pc/f_pc_layer_tag.cpp +++ b/src/f_pc/f_pc_layer_tag.cpp @@ -7,134 +7,86 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct layer_management_tag_class {}; - -struct layer_class {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcLyTg_ToQueue(layer_management_tag_class*, unsigned int, u16, u16); -void fpcLyTg_QueueTo(layer_management_tag_class*); -void fpcLyTg_Move(layer_management_tag_class*, unsigned int, u16, u16); -void fpcLyTg_Init(layer_management_tag_class*, unsigned int, void*); - -extern "C" void fpcLyTg_ToQueue__FP26layer_management_tag_classUiUsUs(); -extern "C" void fpcLyTg_QueueTo__FP26layer_management_tag_class(); -extern "C" void fpcLyTg_Move__FP26layer_management_tag_classUiUsUs(); -extern "C" void fpcLyTg_Init__FP26layer_management_tag_classUiPv(); - -// -// External References: -// - -void fpcLy_IntoQueue(layer_class*, int, create_tag_class*, int); -void fpcLy_ToQueue(layer_class*, int, create_tag_class*); -void fpcLy_QueueTo(layer_class*, create_tag_class*); -void fpcLy_Layer(unsigned int); -void cTg_Create(create_tag_class*, void*); - -extern "C" void fpcLy_IntoQueue__FP11layer_classiP16create_tag_classi(); -extern "C" void fpcLy_ToQueue__FP11layer_classiP16create_tag_class(); -extern "C" void fpcLy_QueueTo__FP11layer_classP16create_tag_class(); -extern "C" void fpcLy_Layer__FUi(); -extern "C" void cTg_Create__FP16create_tag_classPv(); -extern "C" void _savegpr_27(); -extern "C" void _savegpr_28(); -extern "C" void _restgpr_27(); -extern "C" void _restgpr_28(); - // // Declarations: // /* 80021CD4-80021DCC 00F8+00 s=1 e=1 z=0 None .text * fpcLyTg_ToQueue__FP26layer_management_tag_classUiUsUs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyTg_ToQueue(layer_management_tag_class* param_0, unsigned int param_1, u16 param_2, - u16 param_3) { - nofralloc -#include "asm/f_pc/f_pc_layer_tag/fpcLyTg_ToQueue__FP26layer_management_tag_classUiUsUs.s" +s32 fpcLyTg_ToQueue(layer_management_tag_class* pTag, unsigned int layerID, u16 listID, + u16 listPrio) { + if (pTag->mpLayer == NULL && layerID == -1) { + return 0; + } else { + // ghidra says layerID is unsigned? + if (layerID != -1 && layerID != -3 && pTag->mpLayer->mLayerID != layerID) { + pTag->mpLayer = fpcLy_Layer(layerID); + } + if (layerID == -1 || layerID == -3) { + s32 tmp = fpcLy_ToQueue(pTag->mpLayer, listID, &pTag->mCreateTag); + if (tmp != 0x0) { + pTag->mNodeListID = listID; + pTag->mNodeListIdx = tmp - 1; + return 1; + } + } else if (fpcLy_IntoQueue(pTag->mpLayer, listID, &pTag->mCreateTag, listPrio) != 0x0) { + pTag->mNodeListID = listID; + pTag->mNodeListIdx = listPrio; + return 1; + } + return 0; + } } -#pragma pop -/* 80021DCC-80021E2C 0060+00 s=1 e=2 z=0 None .text - * fpcLyTg_QueueTo__FP26layer_management_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyTg_QueueTo(layer_management_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_layer_tag/fpcLyTg_QueueTo__FP26layer_management_tag_class.s" +s32 fpcLyTg_QueueTo(layer_management_tag_class* pTag) { + if (fpcLy_QueueTo(pTag->mpLayer, &pTag->mCreateTag) == 1) { + pTag->mpLayer = NULL; + pTag->mNodeListID = 0xFFFF; + pTag->mNodeListIdx = 0xFFFF; + return 1; + } else { + return 0; + } } -#pragma pop /* 80021E2C-80021EB0 0084+00 s=0 e=1 z=0 None .text * fpcLyTg_Move__FP26layer_management_tag_classUiUsUs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyTg_Move(layer_management_tag_class* param_0, unsigned int param_1, u16 param_2, - u16 param_3) { - nofralloc -#include "asm/f_pc/f_pc_layer_tag/fpcLyTg_Move__FP26layer_management_tag_classUiUsUs.s" +s32 fpcLyTg_Move(layer_management_tag_class* pTag, unsigned int layerID, u16 listID, u16 listPrio) { + layer_class* layer = fpcLy_Layer(layerID); + if (layer == NULL) { + return 0; + } else if (fpcLyTg_QueueTo(pTag) == 0x1) { + pTag->mpLayer = layer; + return fpcLyTg_ToQueue(pTag, layerID, listID, listPrio); + } else { + return 0; + } } -#pragma pop /* ############################################################################################## */ /* 803A3A00-803A3A20 001C+04 s=1 e=0 z=0 None .data crear$2239 */ -SECTION_DATA static u8 crear[28 + 4 /* padding */] = { - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xFF, - 0xFF, - 0xFF, - 0xFF, - /* padding */ - 0x00, - 0x00, - 0x00, - 0x00, +layer_management_tag_class crear = { + NULL, + NULL, + NULL, + NULL, + 0, + NULL, + 0xFFFF, + 0xFFFF, }; /* 80021EB0-80021F64 00B4+00 s=0 e=1 z=0 None .text * fpcLyTg_Init__FP26layer_management_tag_classUiPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLyTg_Init(layer_management_tag_class* param_0, unsigned int param_1, void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_layer_tag/fpcLyTg_Init__FP26layer_management_tag_classUiPv.s" +s32 fpcLyTg_Init(layer_management_tag_class* pTag, unsigned int param2, void* param3) { + layer_class* layer; + *pTag = crear; + cTg_Create(&pTag->mCreateTag, param3); + layer = fpcLy_Layer(param2); + if (layer != NULL) { + pTag->mpLayer = layer; + return 1; + } else { + return 0; + } } -#pragma pop diff --git a/src/f_pc/f_pc_leaf.cpp b/src/f_pc/f_pc_leaf.cpp index e8497a87dc..5b1fd662e3 100644 --- a/src/f_pc/f_pc_leaf.cpp +++ b/src/f_pc/f_pc_leaf.cpp @@ -7,153 +7,71 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct process_method_class {}; - -struct leafdraw_method_class {}; - -struct leafdraw_class {}; - -struct draw_priority_class {}; - -// -// Forward References: -// - -void fpcLf_GetPriority(leafdraw_class const*); -void fpcLf_DrawMethod(leafdraw_method_class*, void*); -static void fpcLf_Draw(leafdraw_class*); -static void fpcLf_Execute(leafdraw_class*); -static void fpcLf_IsDelete(leafdraw_class*); -static void fpcLf_Delete(leafdraw_class*); -static void fpcLf_Create(leafdraw_class*); - -extern "C" void fpcLf_GetPriority__FPC14leafdraw_class(); -extern "C" void fpcLf_DrawMethod__FP21leafdraw_method_classPv(); -extern "C" static void fpcLf_Draw__FP14leafdraw_class(); -extern "C" static void fpcLf_Execute__FP14leafdraw_class(); -extern "C" static void fpcLf_IsDelete__FP14leafdraw_class(); -extern "C" static void fpcLf_Delete__FP14leafdraw_class(); -extern "C" static void fpcLf_Create__FP14leafdraw_class(); -extern "C" extern void* g_fpcLf_Method[5 + 1 /* padding */]; -extern "C" extern u8 g_fpcLf_type[4 + 4 /* padding */]; -extern "C" extern u8 struct_80450D38[8]; - -// -// External References: -// - -void fpcBs_MakeOfType(int*); -void fpcDwPi_Get(draw_priority_class const*); -void fpcDwPi_Init(draw_priority_class*, s16); -void fpcMtd_Method(int (*)(void*), void*); -void fpcMtd_Execute(process_method_class*, void*); -void fpcMtd_IsDelete(process_method_class*, void*); -void fpcMtd_Delete(process_method_class*, void*); -void fpcMtd_Create(process_method_class*, void*); - -extern "C" void fpcBs_MakeOfType__FPi(); -extern "C" void fpcDwPi_Get__FPC19draw_priority_class(); -extern "C" void fpcDwPi_Init__FP19draw_priority_classs(); -extern "C" void fpcMtd_Method__FPFPv_iPv(); -extern "C" void fpcMtd_Execute__FP20process_method_classPv(); -extern "C" void fpcMtd_IsDelete__FP20process_method_classPv(); -extern "C" void fpcMtd_Delete__FP20process_method_classPv(); -extern "C" void fpcMtd_Create__FP20process_method_classPv(); - // // Declarations: // /* 80021A00-80021A24 0024+00 s=0 e=4 z=2 None .text fpcLf_GetPriority__FPC14leafdraw_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLf_GetPriority(leafdraw_class const* param_0) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_GetPriority__FPC14leafdraw_class.s" +s32 fpcLf_GetPriority(const leafdraw_class* pLeaf) { + return fpcDwPi_Get(&pLeaf->mDwPi); } -#pragma pop /* 80021A24-80021A48 0024+00 s=1 e=6 z=0 None .text fpcLf_DrawMethod__FP21leafdraw_method_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLf_DrawMethod(leafdraw_method_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_DrawMethod__FP21leafdraw_method_classPv.s" +s32 fpcLf_DrawMethod(leafdraw_method_class* pMthd, void* pUserData) { + return fpcMtd_Method(pMthd->mpDrawFunc, pUserData); } -#pragma pop /* 80021A48-80021A80 0038+00 s=1 e=0 z=0 None .text fpcLf_Draw__FP14leafdraw_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLf_Draw(leafdraw_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_Draw__FP14leafdraw_class.s" +s32 fpcLf_Draw(leafdraw_class* pLeaf) { + s32 ret = 0; + if (pLeaf->mbUnk0 == 0) + ret = fpcLf_DrawMethod(pLeaf->mpDrawMtd, pLeaf); + return ret; } -#pragma pop /* 80021A80-80021AA8 0028+00 s=1 e=0 z=0 None .text fpcLf_Execute__FP14leafdraw_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLf_Execute(leafdraw_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_Execute__FP14leafdraw_class.s" +s32 fpcLf_Execute(leafdraw_class* pLeaf) { + return fpcMtd_Execute(&pLeaf->mpDrawMtd->mBase, pLeaf); } -#pragma pop /* 80021AA8-80021AD0 0028+00 s=1 e=0 z=0 None .text fpcLf_IsDelete__FP14leafdraw_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLf_IsDelete(leafdraw_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_IsDelete__FP14leafdraw_class.s" +s32 fpcLf_IsDelete(leafdraw_class* pLeaf) { + return fpcMtd_IsDelete(&pLeaf->mpDrawMtd->mBase, pLeaf); } -#pragma pop /* 80021AD0-80021B14 0044+00 s=1 e=0 z=0 None .text fpcLf_Delete__FP14leafdraw_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLf_Delete(leafdraw_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_Delete__FP14leafdraw_class.s" +s32 fpcLf_Delete(leafdraw_class* pLeaf) { + s32 ret = fpcMtd_Delete(&pLeaf->mpDrawMtd->mBase, pLeaf); + if (ret == 1) { + pLeaf->mBase.mSubType = 0; + } + return ret; } -#pragma pop /* ############################################################################################## */ /* 80450D30-80450D38 0004+04 s=1 e=1 z=0 None .sbss g_fpcLf_type */ -u8 g_fpcLf_type[4 + 4 /* padding */]; +int g_fpcLf_type; /* 80021B14-80021B88 0074+00 s=1 e=0 z=0 None .text fpcLf_Create__FP14leafdraw_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLf_Create(leafdraw_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_leaf/fpcLf_Create__FP14leafdraw_class.s" +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(&g_fpcLf_type); + fpcDwPi_Init(&pLeaf->mDwPi, profDef->unk20); + pLeaf->mbUnk0 = 0; + } + return fpcMtd_Create(&pLeaf->mpDrawMtd->mBase, pLeaf); } -#pragma pop /* ############################################################################################## */ /* 803A39E8-803A3A00 0014+04 s=0 e=27 z=756 None .data g_fpcLf_Method */ -SECTION_DATA void* g_fpcLf_Method[5 + 1 /* padding */] = { - (void*)fpcLf_Create__FP14leafdraw_class, - (void*)fpcLf_Delete__FP14leafdraw_class, - (void*)fpcLf_Execute__FP14leafdraw_class, - (void*)fpcLf_IsDelete__FP14leafdraw_class, - (void*)fpcLf_Draw__FP14leafdraw_class, - /* padding */ - NULL, +leafdraw_method_class g_fpcLf_Method = { + (process_method_func)fpcLf_Create, + (process_method_func)fpcLf_Delete, + (process_method_func)fpcLf_Execute, + (process_method_func)fpcLf_IsDelete, + (process_method_func)fpcLf_Draw, }; - -/* 80450D38-80450D40 0008+00 s=0 e=1 z=0 None .sbss None */ -u8 struct_80450D38[8]; diff --git a/src/f_pc/f_pc_line.cpp b/src/f_pc/f_pc_line.cpp index b8b665e54b..29cf9891b3 100644 --- a/src/f_pc/f_pc_line.cpp +++ b/src/f_pc/f_pc_line.cpp @@ -6,51 +6,29 @@ #include "f_pc/f_pc_line.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct node_list_class {}; - -// -// Forward References: -// - -void fpcLn_Create(); - -extern "C" void fpcLn_Create__Fv(); -extern "C" extern void* g_fpcLn_Queue[2]; - -// -// External References: -// - -void cLs_Create(node_list_class*); - -extern "C" void cLs_Create__FP15node_list_class(); +#include "f_pc/f_pc_node.h" // // Declarations: // +#define ARRAY_SIZE(o) (sizeof((o)) / sizeof(*(o))) + /* ############################################################################################## */ /* 803F4CF0-803F4DB0 00C0+00 s=2 e=0 z=0 None .bss l_fpcLn_Line */ -static u8 l_fpcLn_Line[192]; +static node_list_class l_fpcLn_Line[16]; /* 80021F64-80021FB8 0054+00 s=0 e=1 z=0 None .text fpcLn_Create__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLn_Create() { - nofralloc -#include "asm/f_pc/f_pc_line/fpcLn_Create__Fv.s" +void fpcLn_Create(void) { + s32 i = ARRAY_SIZE(l_fpcLn_Line); + node_list_class* pLine = l_fpcLn_Line; + while (i-- > 0) + cLs_Create(pLine++); } -#pragma pop /* ############################################################################################## */ /* 804505D8-804505E0 0008+00 s=0 e=2 z=0 None .sdata g_fpcLn_Queue */ -SECTION_SDATA void* g_fpcLn_Queue[2] = { - (void*)&l_fpcLn_Line, - (void*)0x00000010, +node_lists_tree_class g_fpcLn_Queue = { + l_fpcLn_Line, + ARRAY_SIZE(l_fpcLn_Line), }; diff --git a/src/f_pc/f_pc_line_iter.cpp b/src/f_pc/f_pc_line_iter.cpp index 2b491c9568..e4a0dab586 100644 --- a/src/f_pc/f_pc_line_iter.cpp +++ b/src/f_pc/f_pc_line_iter.cpp @@ -6,47 +6,12 @@ #include "f_pc/f_pc_line_iter.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct node_lists_tree_class {}; - -struct node_class {}; - -struct method_filter {}; - -struct layer_class {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -static void fpcLnIt_MethodCall(create_tag_class*, method_filter*); -void fpcLnIt_Queue(int (*)(void*, void*)); - -extern "C" static void fpcLnIt_MethodCall__FP16create_tag_classP13method_filter(); -extern "C" void fpcLnIt_Queue__FPFPvPv_i(); - -// -// External References: -// - -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_CurrentLayer(); -void cTrIt_Method(node_lists_tree_class*, int (*)(node_class*, void*), void*); -void cTgIt_MethodCall(create_tag_class*, method_filter*); - -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" void cTrIt_Method__FP21node_lists_tree_classPFP10node_classPv_iPv(); -extern "C" void cTgIt_MethodCall__FP16create_tag_classP13method_filter(); -extern "C" void _savegpr_28(); -extern "C" void _restgpr_28(); -extern "C" extern void* g_fpcLn_Queue[2]; +#include "f_pc/f_pc_line.h" +#include "f_pc/f_pc_create_tag.h" +#include "f_pc/f_pc_layer.h" +#include "f_pc/f_pc_base.h" +#include "SSystem/SComponent/c_tag_iter.h" +#include "SSystem/SComponent/c_tree_iter.h" // // Declarations: @@ -54,21 +19,22 @@ extern "C" extern void* g_fpcLn_Queue[2]; /* 800236C0-80023728 0068+00 s=1 e=0 z=0 None .text * fpcLnIt_MethodCall__FP16create_tag_classP13method_filter */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLnIt_MethodCall(create_tag_class* param_0, method_filter* param_1) { - nofralloc -#include "asm/f_pc/f_pc_line_iter/fpcLnIt_MethodCall__FP16create_tag_classP13method_filter.s" +static s32 fpcLnIt_MethodCall(create_tag_class* pTag, method_filter* pFilter) { + layer_class* pLayer = static_cast(pTag->mpTagData)->mLyTg.mpLayer; + layer_class* pCurLayer = fpcLy_CurrentLayer(); + s32 ret; + + fpcLy_SetCurrentLayer(pLayer); + ret = cTgIt_MethodCall(pTag, pFilter); + fpcLy_SetCurrentLayer(pCurLayer); + + return ret; } -#pragma pop /* 80023728-80023764 003C+00 s=0 e=1 z=0 None .text fpcLnIt_Queue__FPFPvPv_i */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLnIt_Queue(int (*)(void*, void*)) { - nofralloc -#include "asm/f_pc/f_pc_line_iter/fpcLnIt_Queue__FPFPvPv_i.s" +void fpcLnIt_Queue(fpcLnIt_QueueFunc pFunc) { + method_filter filter; + filter.mpMethodFunc = (cNdIt_MethodFunc)pFunc; + filter.mpUserData = NULL; + cTrIt_Method(&g_fpcLn_Queue, (cNdIt_MethodFunc)fpcLnIt_MethodCall, &filter); } -#pragma pop diff --git a/src/f_pc/f_pc_line_tag.cpp b/src/f_pc/f_pc_line_tag.cpp index d093bba35c..219d194c6d 100644 --- a/src/f_pc/f_pc_line_tag.cpp +++ b/src/f_pc/f_pc_line_tag.cpp @@ -6,84 +6,42 @@ #include "f_pc/f_pc_line_tag.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct node_lists_tree_class {}; - -struct line_tag {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcLnTg_Move(line_tag*, int); -void fpcLnTg_QueueTo(line_tag*); -void fpcLnTg_ToQueue(line_tag*, int); -void fpcLnTg_Init(line_tag*, void*); - -extern "C" void fpcLnTg_Move__FP8line_tagi(); -extern "C" void fpcLnTg_QueueTo__FP8line_tag(); -extern "C" void fpcLnTg_ToQueue__FP8line_tagi(); -extern "C" void fpcLnTg_Init__FP8line_tagPv(); - -// -// External References: -// - -void cTg_SingleCutFromTree(create_tag_class*); -void cTg_AdditionToTree(node_lists_tree_class*, int, create_tag_class*); -void cTg_Create(create_tag_class*, void*); - -extern "C" void cTg_SingleCutFromTree__FP16create_tag_class(); -extern "C" void cTg_AdditionToTree__FP21node_lists_tree_classiP16create_tag_class(); -extern "C" void cTg_Create__FP16create_tag_classPv(); -extern "C" extern void* g_fpcLn_Queue[2]; +#include "f_pc/f_pc_line.h" // // Declarations: // /* 800235A8-80023600 0058+00 s=0 e=1 z=0 None .text fpcLnTg_Move__FP8line_tagi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLnTg_Move(line_tag* param_0, int param_1) { - nofralloc -#include "asm/f_pc/f_pc_line_tag/fpcLnTg_Move__FP8line_tagi.s" +s32 fpcLnTg_Move(line_tag* pLineTag, int newLineListID) { + if (pLineTag->mLineListID != newLineListID) { + fpcLnTg_QueueTo(pLineTag); + return fpcLnTg_ToQueue(pLineTag, newLineListID); + } + + return 1; } -#pragma pop /* 80023600-80023634 0034+00 s=1 e=1 z=1 None .text fpcLnTg_QueueTo__FP8line_tag */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLnTg_QueueTo(line_tag* param_0) { - nofralloc -#include "asm/f_pc/f_pc_line_tag/fpcLnTg_QueueTo__FP8line_tag.s" +void fpcLnTg_QueueTo(line_tag* pLineTag) { + cTg_SingleCutFromTree(&pLineTag->mBase); + pLineTag->mLineListID = -1; } -#pragma pop /* 80023634-8002368C 0058+00 s=1 e=1 z=1 None .text fpcLnTg_ToQueue__FP8line_tagi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLnTg_ToQueue(line_tag* param_0, int param_1) { - nofralloc -#include "asm/f_pc/f_pc_line_tag/fpcLnTg_ToQueue__FP8line_tagi.s" +s32 fpcLnTg_ToQueue(line_tag* pLineTag, int lineListID) { + s32 ret = cTg_AdditionToTree(&g_fpcLn_Queue, lineListID, &pLineTag->mBase); + + if (ret) { + pLineTag->mLineListID = lineListID; + return 1; + } else { + return 0; + } } -#pragma pop /* 8002368C-800236C0 0034+00 s=0 e=1 z=0 None .text fpcLnTg_Init__FP8line_tagPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLnTg_Init(line_tag* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_line_tag/fpcLnTg_Init__FP8line_tagPv.s" +void fpcLnTg_Init(line_tag* pLineTag, void* pData) { + cTg_Create(&pLineTag->mBase, pData); + pLineTag->mLineListID = -1; } -#pragma pop diff --git a/src/f_pc/f_pc_load.cpp b/src/f_pc/f_pc_load.cpp index 954dbb9028..458cacaba3 100644 --- a/src/f_pc/f_pc_load.cpp +++ b/src/f_pc/f_pc_load.cpp @@ -6,73 +6,43 @@ #include "f_pc/f_pc_load.h" #include "dol2asm.h" #include "dolphin/types.h" +#include "SSystem/SComponent/c_phase.h" -// -// Forward References: -// - -void fpcLd_Use(s16); -static void fpcLd_IsLoaded(s16); -void fpcLd_Free(s16); -void fpcLd_Load(s16); - -extern "C" void fpcLd_Use__Fs(); -extern "C" static void fpcLd_IsLoaded__Fs(); -extern "C" void fpcLd_Free__Fs(); -extern "C" void fpcLd_Load__Fs(); - -// -// External References: -// - -void cDyl_IsLinked(s16); -void cDyl_Unlink(s16); -void cDyl_LinkASync(s16); - -extern "C" void cDyl_IsLinked__Fs(); -extern "C" void cDyl_Unlink__Fs(); -extern "C" void cDyl_LinkASync__Fs(); +extern s32 cDyl_IsLinked(s16 procName); +extern s32 cDyl_Unlink(s16 procName); +extern s32 cDyl_LinkASync(s16 procName); // // Declarations: // /* 80021FB8-80022008 0050+00 s=0 e=1 z=0 None .text fpcLd_Use__Fs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLd_Use(s16 param_0) { - nofralloc -#include "asm/f_pc/f_pc_load/fpcLd_Use__Fs.s" +BOOL fpcLd_Use(s16 procName) { + if (fpcLd_IsLoaded(procName) == TRUE && fpcLd_Load(procName) == cPhs_COMPLEATE_e) + return TRUE; + return FALSE; } -#pragma pop /* 80022008-8002202C 0024+00 s=1 e=0 z=0 None .text fpcLd_IsLoaded__Fs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcLd_IsLoaded(s16 param_0) { - nofralloc -#include "asm/f_pc/f_pc_load/fpcLd_IsLoaded__Fs.s" +s32 fpcLd_IsLoaded(s16 procName) { + return cDyl_IsLinked((int)procName); } -#pragma pop /* 8002202C-80022050 0024+00 s=0 e=2 z=0 None .text fpcLd_Free__Fs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLd_Free(s16 param_0) { - nofralloc -#include "asm/f_pc/f_pc_load/fpcLd_Free__Fs.s" +void fpcLd_Free(s16 procName) { + cDyl_Unlink((int)procName); } -#pragma pop /* 80022050-800220A0 0050+00 s=1 e=1 z=0 None .text fpcLd_Load__Fs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcLd_Load(s16 param_0) { - nofralloc -#include "asm/f_pc/f_pc_load/fpcLd_Load__Fs.s" +s32 fpcLd_Load(s16 procName) { + s32 phase = cDyl_LinkASync((int)procName); + + switch (phase) { + case cPhs_COMPLEATE_e: + return cPhs_COMPLEATE_e; + case 0: + return 0; + default: + return cPhs_ERROR_e; + } } -#pragma pop diff --git a/src/f_pc/f_pc_manager.cpp b/src/f_pc/f_pc_manager.cpp index 73898a4515..ec4d3fc12d 100644 --- a/src/f_pc/f_pc_manager.cpp +++ b/src/f_pc/f_pc_manager.cpp @@ -6,15 +6,30 @@ #include "f_pc/f_pc_manager.h" #include "dol2asm.h" #include "dolphin/types.h" +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_create_iter.h" +#include "f_pc/f_pc_creator.h" +#include "f_pc/f_pc_delete_tag.h" +#include "f_pc/f_pc_deletor.h" +#include "f_pc/f_pc_draw.h" +#include "f_pc/f_pc_executor.h" +#include "f_pc/f_pc_fstcreate_req.h" +#include "f_pc/f_pc_layer_iter.h" +#include "f_pc/f_pc_layer_tag.h" +#include "f_pc/f_pc_layer.h" +#include "f_pc/f_pc_line.h" +#include "f_pc/f_pc_line_iter.h" +#include "f_pc/f_pc_line_tag.h" +#include "f_pc/f_pc_method.h" +#include "f_pc/f_pc_node_req.h" +#include "f_pc/f_pc_pause.h" +#include "f_pc/f_pc_priority.h" +#include "f_pc/f_pc_profile.h" // // Types: // -struct node_list_class {}; - -struct layer_class {}; - struct dShutdownErrorMsg_c { /* 8009D790 */ void execute(); }; @@ -36,8 +51,6 @@ struct dComIfG_play_c { /* 8002CAC4 */ void drawSimpleModel(); }; -struct base_process_class {}; - struct Z2SoundMgr { /* 802AA6B0 */ void pauseAllGameSound(bool); }; @@ -52,19 +65,6 @@ struct JUTGamePad { // Forward References: // -void fpcM_Draw(void*); -static void fpcM_DrawIterater(int (*)(void*, void*)); -void fpcM_Execute(void*); -void fpcM_Delete(void*); -void fpcM_IsCreating(unsigned int); -void fpcM_Management(void (*)(void), void (*)(void)); -void fpcM_Init(); -void fpcM_FastCreate(s16, int (*)(void*), void*, void*); -void fpcM_IsPause(void*, u8); -void fpcM_PauseEnable(void*, u8); -void fpcM_PauseDisable(void*, u8); -void fpcM_JudgeInLayer(unsigned int, void* (*)(void*, void*), void*); - extern "C" void fpcM_Draw__FPv(); extern "C" static void fpcM_DrawIterater__FPFPvPv_i(); extern "C" void fpcM_Execute__FPv(); @@ -82,29 +82,6 @@ extern "C" void fpcM_JudgeInLayer__FUiPFPvPv_PvPv(); // External References: // -void fpcCtIt_JudgeInLayer(unsigned int, void* (*)(void*, void*), void*); -void fpcCt_IsCreatingByID(unsigned int); -void fpcCt_Handler(); -void fpcDt_Handler(); -void fpcDt_Delete(void*); -void fpcEx_Execute(base_process_class*); -void fpcEx_Handler(int (*)(void*, void*)); -void fpcLy_RootLayer(); -void fpcLy_CurrentLayer(); -void fpcLy_Layer(unsigned int); -void fpcLy_Create(layer_class*, void*, node_list_class*, int); -void fpcLyIt_OnlyHere(layer_class*, int (*)(void*, void*), void*); -void fpcLyIt_Judge(layer_class*, void* (*)(void*, void*), void*); -void fpcLn_Create(); -void fpcPi_Handler(); -void fpcPause_IsEnable(void*, u8); -void fpcPause_Enable(void*, u8); -void fpcPause_Disable(void*, u8); -void fpcDw_Execute(base_process_class*); -void fpcDw_Handler(int (*)(int (*)(void*, void*)), int (*)(void*, void*)); -void fpcFCtRq_Request(layer_class*, s16, int (*)(void*, void*), void*, void*); -void cAPIGph_Painter(); -void MtxInit(); extern "C" void fpcCtIt_JudgeInLayer__FUiPFPvPv_PvPv(); extern "C" void fpcCt_IsCreatingByID__FUi(); @@ -149,61 +126,40 @@ extern "C" extern u8 data_80450EC4[4]; // Declarations: // +/* 80450D38-80450D40 0008+00 s=0 e=1 z=0 None .sbss None */ +u8 struct_80450D38[8]; + /* 800220A0-800220C0 0020+00 s=1 e=1 z=0 None .text fpcM_Draw__FPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_Draw(void* param_0) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_Draw__FPv.s" +void fpcM_Draw(void* pProc) { + fpcDw_Execute((base_process_class*)pProc); } -#pragma pop /* 800220C0-800220F8 0038+00 s=1 e=0 z=0 None .text fpcM_DrawIterater__FPFPvPv_i */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcM_DrawIterater(int (*)(void*, void*)) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_DrawIterater__FPFPvPv_i.s" +s32 fpcM_DrawIterater(fpcM_DrawIteraterFunc pFunc) { + return fpcLyIt_OnlyHere(fpcLy_RootLayer(), (fpcLyIt_OnlyHereFunc)pFunc, NULL); } -#pragma pop /* 800220F8-80022118 0020+00 s=1 e=0 z=1 None .text fpcM_Execute__FPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_Execute(void* param_0) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_Execute__FPv.s" +void fpcM_Execute(void* pProc) { + fpcEx_Execute((base_process_class*)pProc); } -#pragma pop /* 80022118-80022138 0020+00 s=0 e=7 z=0 None .text fpcM_Delete__FPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_Delete(void* param_0) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_Delete__FPv.s" +s32 fpcM_Delete(void* pProc) { + return fpcDt_Delete((base_process_class*)pProc); } -#pragma pop /* 80022138-80022158 0020+00 s=0 e=6 z=43 None .text fpcM_IsCreating__FUi */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_IsCreating(unsigned int param_0) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_IsCreating__FUi.s" +BOOL fpcM_IsCreating(unsigned int pID) { + return fpcCt_IsCreatingByID(pID); } -#pragma pop +// TODO, uses a lot of functions outside f_pc/SSystem /* 80022158-800222B8 0160+00 s=0 e=1 z=0 None .text fpcM_Management__FPFv_vPFv_v */ #pragma push #pragma optimization_level 0 #pragma optimizewithasm off -asm void fpcM_Management(void (*)(void), void (*)(void)) { +asm void fpcM_Management(fpcM_ManagementFunc, fpcM_ManagementFunc) { nofralloc #include "asm/f_pc/f_pc_manager/fpcM_Management__FPFv_vPFv_v.s" } @@ -211,67 +167,49 @@ asm void fpcM_Management(void (*)(void), void (*)(void)) { /* ############################################################################################## */ /* 803F4DB0-803F4DDC 002C+00 s=1 e=0 z=0 None .bss rootlayer$3716 */ -static u8 rootlayer[44]; +static layer_class rootlayer; /* 803F4DDC-803F4E58 0078+04 s=1 e=0 z=0 None .bss queue$3717 */ -static u8 queue[120 + 4 /* padding */]; +static node_list_class queue[10]; /* 800222B8-800222F4 003C+00 s=0 e=1 z=0 None .text fpcM_Init__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_Init() { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_Init__Fv.s" +void fpcM_Init(void) { + fpcLy_Create(&rootlayer, NULL, queue, 10); + fpcLn_Create(); } -#pragma pop /* 800222F4-80022348 0054+00 s=0 e=3 z=0 None .text fpcM_FastCreate__FsPFPv_iPvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_FastCreate(s16 param_0, int (*)(void*), void* param_2, void* param_3) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_FastCreate__FsPFPv_iPvPv.s" +base_process_class* fpcM_FastCreate(s16 pProcTypeID, FastCreateReqFunc param_2, void* param_3, + void* pData) { + return fpcFCtRq_Request(fpcLy_CurrentLayer(), pProcTypeID, (fstCreateFunc)param_2, param_3, + pData); } -#pragma pop /* 80022348-8002236C 0024+00 s=0 e=1 z=0 None .text fpcM_IsPause__FPvUc */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_IsPause(void* param_0, u8 param_1) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_IsPause__FPvUc.s" +s32 fpcM_IsPause(void* pProc, u8 param_2) { + return fpcPause_IsEnable((base_process_class*)pProc, param_2 & 0xFF); } -#pragma pop /* 8002236C-80022390 0024+00 s=0 e=1 z=0 None .text fpcM_PauseEnable__FPvUc */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_PauseEnable(void* param_0, u8 param_1) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_PauseEnable__FPvUc.s" +void fpcM_PauseEnable(void* pProc, u8 param_2) { + fpcPause_Enable((process_node_class*)pProc, param_2 & 0xFF); } -#pragma pop /* 80022390-800223B4 0024+00 s=0 e=1 z=0 None .text fpcM_PauseDisable__FPvUc */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_PauseDisable(void* param_0, u8 param_1) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_PauseDisable__FPvUc.s" +void fpcM_PauseDisable(void* pProc, u8 param_2) { + fpcPause_Disable((process_node_class*)pProc, param_2 & 0xFF); } -#pragma pop /* 800223B4-80022428 0074+00 s=0 e=1 z=0 None .text fpcM_JudgeInLayer__FUiPFPvPv_PvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcM_JudgeInLayer(unsigned int param_0, void* (*)(void*, void*), void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_manager/fpcM_JudgeInLayer__FUiPFPvPv_PvPv.s" +void* fpcM_JudgeInLayer(unsigned int pLayerID, fpcCtIt_JudgeFunc 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; + } } -#pragma pop diff --git a/src/f_pc/f_pc_method.cpp b/src/f_pc/f_pc_method.cpp index 7a8322d3d5..a4af37cd0a 100644 --- a/src/f_pc/f_pc_method.cpp +++ b/src/f_pc/f_pc_method.cpp @@ -7,86 +7,38 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct process_method_class {}; - -// -// Forward References: -// - -void fpcMtd_Method(int (*)(void*), void*); -void fpcMtd_Execute(process_method_class*, void*); -void fpcMtd_IsDelete(process_method_class*, void*); -void fpcMtd_Delete(process_method_class*, void*); -void fpcMtd_Create(process_method_class*, void*); - -extern "C" void fpcMtd_Method__FPFPv_iPv(); -extern "C" void fpcMtd_Execute__FP20process_method_classPv(); -extern "C" void fpcMtd_IsDelete__FP20process_method_classPv(); -extern "C" void fpcMtd_Delete__FP20process_method_classPv(); -extern "C" void fpcMtd_Create__FP20process_method_classPv(); - -// -// External References: -// - // // Declarations: // /* 80022428-80022460 0038+00 s=4 e=6 z=0 None .text fpcMtd_Method__FPFPv_iPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtd_Method(int (*)(void*), void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_method/fpcMtd_Method__FPFPv_iPv.s" +s32 fpcMtd_Method(process_method_func pFunc, void* pUserData) { + if (pFunc != NULL) + return pFunc(pUserData); + else + return 1; } -#pragma pop /* 80022460-80022484 0024+00 s=0 e=10 z=0 None .text fpcMtd_Execute__FP20process_method_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtd_Execute(process_method_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_method/fpcMtd_Execute__FP20process_method_classPv.s" +s32 fpcMtd_Execute(process_method_class* pMthd, void* pUserData) { + return fpcMtd_Method(pMthd->mpExecuteFunc, pUserData); } -#pragma pop /* 80022484-800224A8 0024+00 s=0 e=10 z=0 None .text fpcMtd_IsDelete__FP20process_method_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtd_IsDelete(process_method_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_method/fpcMtd_IsDelete__FP20process_method_classPv.s" +s32 fpcMtd_IsDelete(process_method_class* pMthd, void* pUserData) { + return fpcMtd_Method(pMthd->mpIsDeleteFunc, pUserData); } -#pragma pop /* 800224A8-800224CC 0024+00 s=0 e=10 z=0 None .text fpcMtd_Delete__FP20process_method_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtd_Delete(process_method_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_method/fpcMtd_Delete__FP20process_method_classPv.s" +s32 fpcMtd_Delete(process_method_class* pMthd, void* pUserData) { + return fpcMtd_Method(pMthd->mpDeleteFunc, pUserData); } -#pragma pop /* 800224CC-800224F0 0024+00 s=0 e=10 z=0 None .text fpcMtd_Create__FP20process_method_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtd_Create(process_method_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_method/fpcMtd_Create__FP20process_method_classPv.s" +s32 fpcMtd_Create(process_method_class* pMthd, void* pUserData) { + return fpcMtd_Method(pMthd->mpCreateFunc, pUserData); } -#pragma pop diff --git a/src/f_pc/f_pc_method_iter.cpp b/src/f_pc/f_pc_method_iter.cpp index 4e614450e6..ddc72e3852 100644 --- a/src/f_pc/f_pc_method_iter.cpp +++ b/src/f_pc/f_pc_method_iter.cpp @@ -7,41 +7,12 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct node_list_class {}; - -struct node_class {}; - -// -// Forward References: -// - -void fpcMtdIt_Method(node_list_class*, int (*)(void*)); - -extern "C" void fpcMtdIt_Method__FP15node_list_classPFPv_i(); - -// -// External References: -// - -void cLsIt_Method(node_list_class*, int (*)(node_class*, void*), void*); - -extern "C" void cLsIt_Method__FP15node_list_classPFP10node_classPv_iPv(); - // // Declarations: // /* 80023764-80023788 0024+00 s=0 e=1 z=0 None .text fpcMtdIt_Method__FP15node_list_classPFPv_i */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtdIt_Method(node_list_class* param_0, int (*)(void*)) { - nofralloc -#include "asm/f_pc/f_pc_method_iter/fpcMtdIt_Method__FP15node_list_classPFPv_i.s" +void fpcMtdIt_Method(node_list_class* pList, fpcMtdIt_MethodFunc pMethod) { + cLsIt_Method(pList, (cNdIt_MethodFunc)pMethod, NULL); } -#pragma pop diff --git a/src/f_pc/f_pc_method_tag.cpp b/src/f_pc/f_pc_method_tag.cpp index 125a3c1ebe..db16d95652 100644 --- a/src/f_pc/f_pc_method_tag.cpp +++ b/src/f_pc/f_pc_method_tag.cpp @@ -7,88 +7,33 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Types: -// - -struct process_method_tag_class {}; - -struct node_list_class {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcMtdTg_Do(process_method_tag_class*); -void fpcMtdTg_ToMethodQ(node_list_class*, process_method_tag_class*); -void fpcMtdTg_MethodQTo(process_method_tag_class*); -void fpcMtdTg_Init(process_method_tag_class*, int (*)(void*), void*); - -extern "C" void fpcMtdTg_Do__FP24process_method_tag_class(); -extern "C" void fpcMtdTg_ToMethodQ__FP15node_list_classP24process_method_tag_class(); -extern "C" void fpcMtdTg_MethodQTo__FP24process_method_tag_class(); -extern "C" void fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv(); - -// -// External References: -// - -void cTg_SingleCut(create_tag_class*); -void cTg_Addition(node_list_class*, create_tag_class*); -void cTg_Create(create_tag_class*, void*); - -extern "C" void cTg_SingleCut__FP16create_tag_class(); -extern "C" void cTg_Addition__FP15node_list_classP16create_tag_class(); -extern "C" void cTg_Create__FP16create_tag_classPv(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_29(); - // // Declarations: // /* 80023788-800237B8 0030+00 s=0 e=1 z=0 None .text fpcMtdTg_Do__FP24process_method_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtdTg_Do(process_method_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_method_tag/fpcMtdTg_Do__FP24process_method_tag_class.s" +s32 fpcMtdTg_Do(process_method_tag_class* pMthd) { + return pMthd->mpFunc(pMthd->mpMthdData); } -#pragma pop /* 800237B8-800237D8 0020+00 s=0 e=1 z=0 None .text * fpcMtdTg_ToMethodQ__FP15node_list_classP24process_method_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtdTg_ToMethodQ(node_list_class* param_0, process_method_tag_class* param_1) { - nofralloc -#include "asm/f_pc/f_pc_method_tag/fpcMtdTg_ToMethodQ__FP15node_list_classP24process_method_tag_class.s" +s32 fpcMtdTg_ToMethodQ(node_list_class* pList, process_method_tag_class* pMthd) { + return cTg_Addition(pList, &pMthd->mCreateTag); } -#pragma pop /* 800237D8-800237F8 0020+00 s=0 e=1 z=0 None .text * fpcMtdTg_MethodQTo__FP24process_method_tag_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtdTg_MethodQTo(process_method_tag_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_method_tag/fpcMtdTg_MethodQTo__FP24process_method_tag_class.s" +void fpcMtdTg_MethodQTo(process_method_tag_class* pMthd) { + cTg_SingleCut(&pMthd->mCreateTag); } -#pragma pop /* 800237F8-80023844 004C+00 s=0 e=3 z=0 None .text * fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcMtdTg_Init(process_method_tag_class* param_0, int (*)(void*), void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_method_tag/fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv.s" +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; } -#pragma pop diff --git a/src/f_pc/f_pc_node.cpp b/src/f_pc/f_pc_node.cpp index 406444b6be..5d60fd2a3b 100644 --- a/src/f_pc/f_pc_node.cpp +++ b/src/f_pc/f_pc_node.cpp @@ -6,80 +6,7 @@ #include "f_pc/f_pc_node.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct process_node_class {}; - -struct process_method_class {}; - -struct nodedraw_method_class {}; - -struct node_list_class {}; - -struct layer_class {}; - -// -// Forward References: -// - -void fpcNd_DrawMethod(nodedraw_method_class*, void*); -static void fpcNd_Draw(process_node_class*); -static void fpcNd_Execute(process_node_class*); -static void fpcNd_IsCreatingFromUnder(void*); -void fpcNd_IsDeleteTiming(process_node_class*); -static void fpcNd_IsDelete(process_node_class*); -static void fpcNd_Delete(process_node_class*); -static void fpcNd_Create(process_node_class*); - -extern "C" void fpcNd_DrawMethod__FP21nodedraw_method_classPv(); -extern "C" static void fpcNd_Draw__FP18process_node_class(); -extern "C" static void fpcNd_Execute__FP18process_node_class(); -extern "C" static void fpcNd_IsCreatingFromUnder__FPv(); -extern "C" void fpcNd_IsDeleteTiming__FP18process_node_class(); -extern "C" static void fpcNd_IsDelete__FP18process_node_class(); -extern "C" static void fpcNd_Delete__FP18process_node_class(); -extern "C" static void fpcNd_Create__FP18process_node_class(); -extern "C" extern void* g_fpcNd_Method[5 + 1 /* padding */]; -extern "C" extern u8 g_fpcNd_type[4 + 4 /* padding */]; - -// -// External References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcBs_MakeOfType(int*); -void fpcLy_IsDeletingMesg(layer_class*); -void fpcLy_IsCreatingMesg(layer_class*); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLy_CurrentLayer(); -void fpcLy_Delete(layer_class*); -void fpcLy_Create(layer_class*, void*, node_list_class*, int); -void fpcLyIt_Judge(layer_class*, void* (*)(void*, void*), void*); -void fpcMtd_Method(int (*)(void*), void*); -void fpcMtd_Execute(process_method_class*, void*); -void fpcMtd_IsDelete(process_method_class*, void*); -void fpcMtd_Delete(process_method_class*, void*); -void fpcMtd_Create(process_method_class*, void*); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcBs_MakeOfType__FPi(); -extern "C" void fpcLy_IsDeletingMesg__FP11layer_class(); -extern "C" void fpcLy_IsCreatingMesg__FP11layer_class(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" void fpcLy_Delete__FP11layer_class(); -extern "C" void fpcLy_Create__FP11layer_classPvP15node_list_classi(); -extern "C" void fpcLyIt_Judge__FP11layer_classPFPvPv_PvPv(); -extern "C" void fpcMtd_Method__FPFPv_iPv(); -extern "C" void fpcMtd_Execute__FP20process_method_classPv(); -extern "C" void fpcMtd_IsDelete__FP20process_method_classPv(); -extern "C" void fpcMtd_Delete__FP20process_method_classPv(); -extern "C" void fpcMtd_Create__FP20process_method_classPv(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_29(); +#include "f_pc/f_pc_layer_iter.h" // // Declarations: @@ -87,106 +14,112 @@ extern "C" void _restgpr_29(); /* 800224F0-80022514 0024+00 s=1 e=1 z=0 None .text fpcNd_DrawMethod__FP21nodedraw_method_classPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNd_DrawMethod(nodedraw_method_class* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_DrawMethod__FP21nodedraw_method_classPv.s" +s32 fpcNd_DrawMethod(nodedraw_method_class* pNodeMethod, void* pData) { + return fpcMtd_Method(pNodeMethod->mNodedrawFunc, pData); } -#pragma pop /* 80022514-80022580 006C+00 s=1 e=0 z=0 None .text fpcNd_Draw__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNd_Draw(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_Draw__FP18process_node_class.s" +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; } -#pragma pop /* 80022580-800225DC 005C+00 s=1 e=0 z=0 None .text fpcNd_Execute__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNd_Execute(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_Execute__FP18process_node_class.s" +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; } -#pragma pop /* ############################################################################################## */ /* 80450D40-80450D48 0004+04 s=2 e=11 z=0 None .sbss g_fpcNd_type */ -u8 g_fpcNd_type[4 + 4 /* padding */]; +int g_fpcNd_type; /* 800225DC-8002265C 0080+00 s=1 e=0 z=0 None .text fpcNd_IsCreatingFromUnder__FPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNd_IsCreatingFromUnder(void* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_IsCreatingFromUnder__FPv.s" +void* fpcNd_IsCreatingFromUnder(void* pProcNodeV) { + layer_class* layer; + process_node_class* pProcNode = static_cast(pProcNodeV); + if (pProcNode != NULL && + fpcBs_Is_JustOfType(g_fpcNd_type, pProcNode->mBase.mSubType) != FALSE) { + layer = &pProcNode->mLayer; + if (fpcLy_IsCreatingMesg(layer) == 0x0) { + return (process_node_class*)fpcLyIt_Judge( + layer, (fpcLyIt_JudgeFunc)fpcNd_IsCreatingFromUnder, NULL); + } else { + return pProcNode; + } + } else { + return NULL; + } } -#pragma pop /* ############################################################################################## */ /* 804505E0-804505E8 0004+04 s=1 e=0 z=0 None .sdata g_fpcNd_IsCheckOfDeleteTiming */ -SECTION_SDATA static u32 g_fpcNd_IsCheckOfDeleteTiming[1 + 1 /* padding */] = { - 0x00000001, - /* padding */ - 0x00000000, -}; +static s32 g_fpcNd_IsCheckOfDeleteTiming = 1; /* 8002265C-8002269C 0040+00 s=0 e=2 z=0 None .text fpcNd_IsDeleteTiming__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNd_IsDeleteTiming(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_IsDeleteTiming__FP18process_node_class.s" +s32 fpcNd_IsDeleteTiming(process_node_class* pProcNode) { + if (g_fpcNd_IsCheckOfDeleteTiming == 0x1 && fpcNd_IsCreatingFromUnder(pProcNode) != NULL) { + return 0; + } else { + return 1; + } } -#pragma pop /* 8002269C-800226C4 0028+00 s=1 e=0 z=0 None .text fpcNd_IsDelete__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNd_IsDelete(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_IsDelete__FP18process_node_class.s" +s32 fpcNd_IsDelete(process_node_class* pProcNode) { + return fpcMtd_IsDelete(&pProcNode->mpNodeMtd->mBase, pProcNode); } -#pragma pop /* 800226C4-80022728 0064+00 s=1 e=0 z=0 None .text fpcNd_Delete__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNd_Delete(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_Delete__FP18process_node_class.s" +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; + } } -#pragma pop /* 80022728-800227C4 009C+00 s=1 e=0 z=0 None .text fpcNd_Create__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNd_Create(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node/fpcNd_Create__FP18process_node_class.s" +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(&g_fpcNd_type); + 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; } -#pragma pop /* ############################################################################################## */ /* 803A3A20-803A3A38 0014+04 s=0 e=9 z=0 None .data g_fpcNd_Method */ -SECTION_DATA void* g_fpcNd_Method[5 + 1 /* padding */] = { - (void*)fpcNd_Create__FP18process_node_class, - (void*)fpcNd_Delete__FP18process_node_class, - (void*)fpcNd_Execute__FP18process_node_class, - (void*)fpcNd_IsDelete__FP18process_node_class, - (void*)fpcNd_Draw__FP18process_node_class, - /* padding */ - NULL, +nodedraw_method_class g_fpcNd_Method = { + (process_method_func)fpcNd_Create, + (process_method_func)fpcNd_Delete, + (process_method_func)fpcNd_Execute, + (process_method_func)fpcNd_IsDelete, + (process_method_func)fpcNd_Draw, }; diff --git a/src/f_pc/f_pc_node_req.cpp b/src/f_pc/f_pc_node_req.cpp index 81cf911e09..4a3adb2919 100644 --- a/src/f_pc/f_pc_node_req.cpp +++ b/src/f_pc/f_pc_node_req.cpp @@ -6,125 +6,15 @@ #include "f_pc/f_pc_node_req.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct request_of_phase_process_class {}; - -struct process_node_class {}; - -struct process_method_tag_class {}; - -struct node_list_class {}; - -struct node_create_request_method_class {}; - -struct node_create_request {}; - -struct layer_class {}; - -struct create_tag_class {}; - -struct cMl { - /* 80263228 */ void memalignB(int, u32); - /* 80263260 */ void free(void*); -}; - -// -// Forward References: -// - -static void fpcNdRq_RequestQTo(node_create_request*); -static void fpcNdRq_ToRequestQ(node_create_request*); -static void fpcNdRq_phase_IsCreated(node_create_request*); -static void fpcNdRq_phase_Create(node_create_request*); -static s32 fpcNdRq_phase_IsDeleteTiming(node_create_request*); -static void fpcNdRq_phase_IsDeleted(node_create_request*); -static void fpcNdRq_phase_Delete(node_create_request*); -static void fpcNdRq_DoPhase(node_create_request*); -void fpcNdRq_Execute(node_create_request*); -void fpcNdRq_Delete(node_create_request*); -static void fpcNdRq_Cancel(node_create_request*); -void fpcNdRq_Handler(); -static void fpcNdRq_IsPossibleTarget(process_node_class*); -static void fpcNdRq_IsIng(process_node_class*); -static void fpcNdRq_Create(u32); -static void fpcNdRq_ChangeNode(u32, process_node_class*, s16, void*); -static void fpcNdRq_DeleteNode(u32, process_node_class*); -static void fpcNdRq_CreateNode(u32, s16, void*); -void fpcNdRq_Request(u32, int, process_node_class*, s16, void*, node_create_request_method_class*); -static void fpcNdRq_ReChangeNode(unsigned int, s16, void*); -void fpcNdRq_ReRequest(unsigned int, s16, void*); - -extern "C" static void fpcNdRq_RequestQTo__FP19node_create_request(); -extern "C" static void fpcNdRq_ToRequestQ__FP19node_create_request(); -extern "C" static void fpcNdRq_phase_IsCreated__FP19node_create_request(); -extern "C" static void fpcNdRq_phase_Create__FP19node_create_request(); -extern "C" static s32 fpcNdRq_phase_IsDeleteTiming__FP19node_create_request(); -extern "C" static void fpcNdRq_phase_IsDeleted__FP19node_create_request(); -extern "C" static void fpcNdRq_phase_Delete__FP19node_create_request(); -extern "C" static void fpcNdRq_DoPhase__FP19node_create_request(); -extern "C" void fpcNdRq_Execute__FP19node_create_request(); -extern "C" void fpcNdRq_Delete__FP19node_create_request(); -extern "C" static void fpcNdRq_Cancel__FP19node_create_request(); -extern "C" void fpcNdRq_Handler__Fv(); -extern "C" static void fpcNdRq_IsPossibleTarget__FP18process_node_class(); -extern "C" static void fpcNdRq_IsIng__FP18process_node_class(); -extern "C" static void fpcNdRq_Create__FUl(); -extern "C" static void fpcNdRq_ChangeNode__FUlP18process_node_classsPv(); -extern "C" static void fpcNdRq_DeleteNode__FUlP18process_node_class(); -extern "C" static void fpcNdRq_CreateNode__FUlsPv(); -extern "C" void fpcNdRq_Request__FUliP18process_node_classsPvP32node_create_request_method_class(); -extern "C" static void fpcNdRq_ReChangeNode__FUisPv(); -extern "C" void fpcNdRq_ReRequest__FUisPv(); - -// -// External References: -// - -void fpcCtRq_IsCreatingByID(unsigned int); -void fpcDt_IsComplete(); -void fpcDt_Delete(void*); -void fpcEx_IsExist(unsigned int); -void fpcLy_CancelQTo(process_method_tag_class*); -void fpcLy_ToCancelQ(layer_class*, process_method_tag_class*); -void fpcLy_CreatingMesg(layer_class*); -void fpcLy_CreatedMesg(layer_class*); -void fpcLy_CurrentLayer(); -void fpcMtd_Method(int (*)(void*), void*); -void fpcMtdTg_Init(process_method_tag_class*, int (*)(void*), void*); -void fpcSCtRq_Request(layer_class*, s16, int (*)(void*, void*), void*, void*); -void cPhs_Handler(request_of_phase_process_class*, int (**)(void*), void*); -void cTg_SingleCut(create_tag_class*); -void cTg_Addition(node_list_class*, create_tag_class*); -void cTg_Create(create_tag_class*, void*); -void sBs_ClearArea(void*, u32); - -extern "C" void fpcCtRq_IsCreatingByID__FUi(); -extern "C" void fpcDt_IsComplete__Fv(); -extern "C" void fpcDt_Delete__FPv(); -extern "C" void fpcEx_IsExist__FUi(); -extern "C" void fpcLy_CancelQTo__FP24process_method_tag_class(); -extern "C" void fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class(); -extern "C" void fpcLy_CreatingMesg__FP11layer_class(); -extern "C" void fpcLy_CreatedMesg__FP11layer_class(); -extern "C" void fpcLy_CurrentLayer__Fv(); -extern "C" void fpcMtd_Method__FPFPv_iPv(); -extern "C" void fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv(); -extern "C" void fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv(); -extern "C" void memalignB__3cMlFiUl(); -extern "C" void free__3cMlFPv(); -extern "C" void cPhs_Handler__FP30request_of_phase_process_classPPFPv_iPv(); -extern "C" void cTg_SingleCut__FP16create_tag_class(); -extern "C" void cTg_Addition__FP15node_list_classP16create_tag_class(); -extern "C" void cTg_Create__FP16create_tag_classPv(); -extern "C" void sBs_ClearArea__FPvUl(); -extern "C" void _savegpr_28(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_28(); -extern "C" void _restgpr_29(); +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_create_req.h" +#include "f_pc/f_pc_creator.h" +#include "f_pc/f_pc_deletor.h" +#include "f_pc/f_pc_executor.h" +#include "f_pc/f_pc_layer.h" +#include "f_pc/f_pc_stdcreate_req.h" +#include "SSystem/SComponent/c_malloc.h" +#include "SSystem/SStandard/s_basic.h" // // Declarations: @@ -132,274 +22,343 @@ extern "C" void _restgpr_29(); /* 800227C4-80022804 0040+00 s=1 e=0 z=0 None .text fpcNdRq_RequestQTo__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_RequestQTo(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_RequestQTo__FP19node_create_request.s" +void fpcNdRq_RequestQTo(node_create_request* pNodeCreateReq) { + fpcLy_CreatedMesg(pNodeCreateReq->mpLayerClass); + fpcLy_CancelQTo(&pNodeCreateReq->mProcMthCls); + cTg_SingleCut(&pNodeCreateReq->mCreateTag); } -#pragma pop /* ############################################################################################## */ /* 803A3A38-803A3A44 000C+00 s=5 e=0 z=0 None .data l_fpcNdRq_Queue */ -SECTION_DATA static u8 l_fpcNdRq_Queue[12] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +static node_list_class l_fpcNdRq_Queue = { + NULL, NULL, 0 }; /* 80022804-80022850 004C+00 s=1 e=0 z=0 None .text fpcNdRq_ToRequestQ__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_ToRequestQ(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_ToRequestQ__FP19node_create_request.s" +void fpcNdRq_ToRequestQ(node_create_request* pNodeCreateReq) { + cTg_Addition(&l_fpcNdRq_Queue, &pNodeCreateReq->mCreateTag); + fpcLy_ToCancelQ(pNodeCreateReq->mpLayerClass, &pNodeCreateReq->mProcMthCls); + fpcLy_CreatingMesg(pNodeCreateReq->mpLayerClass); } -#pragma pop /* 80022850-800228A8 0058+00 s=2 e=0 z=0 None .text * fpcNdRq_phase_IsCreated__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_phase_IsCreated(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_phase_IsCreated__FP19node_create_request.s" +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; + } } -#pragma pop /* 800228A8-80022904 005C+00 s=2 e=0 z=0 None .text fpcNdRq_phase_Create__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_phase_Create(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_phase_Create__FP19node_create_request.s" +s32 fpcNdRq_phase_Create(node_create_request* pNodeCreateReq) { + pNodeCreateReq->mCreatingID = + fpcSCtRq_Request(pNodeCreateReq->mpLayerClass, pNodeCreateReq->mProcName, + (stdCreateFunc)pNodeCreateReq->mpNodeCrReqMthCls->mpPostMethodFunc, + pNodeCreateReq, pNodeCreateReq->mpUserData); + return pNodeCreateReq->mCreatingID == -1 ? 3 : 2; } -#pragma pop /* 80022904-8002290C 0008+00 s=2 e=0 z=0 None .text * fpcNdRq_phase_IsDeleteTiming__FP19node_create_request */ -static s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* param_0) { +s32 fpcNdRq_phase_IsDeleteTiming(node_create_request* pNodeCreateReq) { return 2; } /* 8002290C-8002293C 0030+00 s=2 e=0 z=0 None .text * fpcNdRq_phase_IsDeleted__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_phase_IsDeleted(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_phase_IsDeleted__FP19node_create_request.s" +s32 fpcNdRq_phase_IsDeleted(node_create_request* pNodeCreateReq) { + return fpcDt_IsComplete() == 0 ? cPhs_ZERO_e : 2; } -#pragma pop /* 8002293C-80022990 0054+00 s=2 e=0 z=0 None .text fpcNdRq_phase_Delete__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_phase_Delete(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_phase_Delete__FP19node_create_request.s" +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; } -#pragma pop /* 80022990-800229D8 0048+00 s=1 e=0 z=0 None .text fpcNdRq_DoPhase__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_DoPhase(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_DoPhase__FP19node_create_request.s" +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; } -#pragma pop /* 800229D8-80022A3C 0064+00 s=0 e=1 z=0 None .text fpcNdRq_Execute__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNdRq_Execute(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_Execute__FP19node_create_request.s" +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; + } } -#pragma pop /* 80022A3C-80022AA4 0068+00 s=2 e=1 z=0 None .text fpcNdRq_Delete__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNdRq_Delete(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_Delete__FP19node_create_request.s" +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::free(pNodeCreateReq); + return 1; } -#pragma pop /* 80022AA4-80022AFC 0058+00 s=2 e=0 z=0 None .text fpcNdRq_Cancel__FP19node_create_request */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_Cancel(node_create_request* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_Cancel__FP19node_create_request.s" +s32 fpcNdRq_Cancel(node_create_request* pNodeCreateReq) { + if (pNodeCreateReq->mpNodeCrReqMthCls != NULL && + fpcMtd_Method(pNodeCreateReq->mpNodeCrReqMthCls->mpCancelFunc, pNodeCreateReq) == 0) { + return 0; + } + return fpcNdRq_Delete(pNodeCreateReq); } -#pragma pop /* 80022AFC-80022BE4 00E8+00 s=0 e=1 z=0 None .text fpcNdRq_Handler__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNdRq_Handler() { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_Handler__Fv.s" +#define NODE_GET_NEXT(pNode) (pNode ? pNode->mpNextNode : NULL) +s32 fpcNdRq_Handler(void) { + node_class* currentNode = l_fpcNdRq_Queue.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; } -#pragma pop /* 80022BE4-80022C50 006C+00 s=3 e=0 z=0 None .text * fpcNdRq_IsPossibleTarget__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_IsPossibleTarget(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_IsPossibleTarget__FP18process_node_class.s" +s32 fpcNdRq_IsPossibleTarget(process_node_class* pProcNode) { + s32 bsPcId = pProcNode->mBase.mBsPcId; + request_node_class* currentNode; + node_create_request* currentNdCr; + currentNode = (request_node_class*)l_fpcNdRq_Queue.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((¤tNode->mBase)); + } + return 1; } -#pragma pop /* 80022C50-80022C9C 004C+00 s=2 e=0 z=0 None .text fpcNdRq_IsIng__FP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_IsIng(process_node_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_IsIng__FP18process_node_class.s" +s32 fpcNdRq_IsIng(process_node_class* pProcNode) { + request_node_class* currentNode; + node_create_request* currentNodeReq; + s32 bsPcId = pProcNode->mBase.mBsPcId; + currentNode = (request_node_class*)l_fpcNdRq_Queue.mpHead; + while (currentNode != NULL) { + currentNodeReq = currentNode->mNodeCrReq; + if (currentNodeReq->mCreatingID == bsPcId) { + return 1; + } + currentNode = (request_node_class*)NODE_GET_NEXT((¤tNode->mBase)); + } + return 0; } -#pragma pop /* ############################################################################################## */ /* 803A3A44-803A3AA8 0064+00 s=1 e=0 z=0 None .data clear$2359 */ -SECTION_DATA static u8 clear[100] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, - 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x7F, 0xFF, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0x00, 0x00, +static node_create_request clear = { + NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, 0, NULL, NULL, + NULL, 0, 0, + NULL, 5, 0xFFFFFFFF, + NULL, 0xFFFFFFFE, + NULL, 0xFFFFFFFE, + 0x7FFF, NULL, + 0x7FFF }; -/* 80450D48-80450D4C 0004+00 s=1 e=0 z=0 None .sbss request_id$2360 */ -static u8 request_id[4]; - -/* 80450D4C-80450D50 0004+00 s=1 e=0 z=0 None .sbss None */ -static u8 data_80450D4C[4]; - /* 80022C9C-80022E14 0178+00 s=3 e=0 z=0 None .text fpcNdRq_Create__FUl */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_Create(u32 param_0) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_Create__FUl.s" +node_create_request* fpcNdRq_Create(u32 pRequestSize) { + node_create_request* req = (node_create_request*)cMl::memalignB(-4, pRequestSize); + if (req != NULL) { + static int request_id = 0; + sBs_ClearArea(req, pRequestSize); + *req = clear; + cTg_Create(&req->mCreateTag, req); + fpcMtdTg_Init(&req->mProcMthCls, (process_method_tag_func)fpcNdRq_Cancel, req); + req->mRequestId = request_id++; + } + return req; } -#pragma pop /* ############################################################################################## */ /* 803A3AA8-803A3AC0 0018+00 s=1 e=0 z=0 None .data methods$2376 */ -SECTION_DATA static void* methods_2376[6] = { - (void*)fpcNdRq_phase_IsDeleteTiming__FP19node_create_request, - (void*)fpcNdRq_phase_Delete__FP19node_create_request, - (void*)fpcNdRq_phase_IsDeleted__FP19node_create_request, - (void*)fpcNdRq_phase_Create__FP19node_create_request, - (void*)fpcNdRq_phase_IsCreated__FP19node_create_request, - (void*)NULL, +static cPhs__Handler methods_2376[6] = { + (cPhs__Handler)fpcNdRq_phase_IsDeleteTiming, + (cPhs__Handler)fpcNdRq_phase_Delete, + (cPhs__Handler)fpcNdRq_phase_IsDeleted, + (cPhs__Handler)fpcNdRq_phase_Create, + (cPhs__Handler)fpcNdRq_phase_IsCreated, + NULL, }; /* 80022E14-80022EB0 009C+00 s=1 e=0 z=0 None .text * fpcNdRq_ChangeNode__FUlP18process_node_classsPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_ChangeNode(u32 param_0, process_node_class* param_1, s16 param_2, - void* param_3) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_ChangeNode__FUlP18process_node_classsPv.s" +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 = methods_2376; + 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; + } } -#pragma pop /* ############################################################################################## */ /* 803A3AC0-803A3AD0 0010+00 s=1 e=0 z=0 None .data methods$2386 */ -SECTION_DATA static void* methods_2386[4] = { - (void*)fpcNdRq_phase_IsDeleteTiming__FP19node_create_request, - (void*)fpcNdRq_phase_Delete__FP19node_create_request, - (void*)fpcNdRq_phase_IsDeleted__FP19node_create_request, - (void*)NULL, +static cPhs__Handler methods_2386[4] = { + (cPhs__Handler)fpcNdRq_phase_IsDeleteTiming, + (cPhs__Handler)fpcNdRq_phase_Delete, + (cPhs__Handler)fpcNdRq_phase_IsDeleted, + NULL, }; /* 80022EB0-80022F3C 008C+00 s=1 e=0 z=0 None .text fpcNdRq_DeleteNode__FUlP18process_node_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_DeleteNode(u32 param_0, process_node_class* param_1) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_DeleteNode__FUlP18process_node_class.s" +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 = methods_2386; + req->mNodeProc.mpNodeProc = pProcNode; + req->mNodeProc.mProcId = pProcNode->mBase.mBsPcId; + req->mpLayerClass = pProcNode->mBase.mLyTg.mpLayer; + } + return req; + } else { + return NULL; + } } -#pragma pop /* ############################################################################################## */ /* 803A3AD0-803A3AE0 000C+04 s=1 e=0 z=0 None .data methods$2397 */ -SECTION_DATA static void* methods_2397[3 + 1 /* padding */] = { - (void*)fpcNdRq_phase_Create__FP19node_create_request, - (void*)fpcNdRq_phase_IsCreated__FP19node_create_request, - (void*)NULL, - /* padding */ +static cPhs__Handler methods_2397[3] = { + (cPhs__Handler)fpcNdRq_phase_Create, + (cPhs__Handler)fpcNdRq_phase_IsCreated, NULL, }; /* 80022F3C-80022FE8 00AC+00 s=1 e=0 z=0 None .text fpcNdRq_CreateNode__FUlsPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_CreateNode(u32 param_0, s16 param_1, void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_CreateNode__FUlsPv.s" +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 = methods_2397; + 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; + } } -#pragma pop /* 80022FE8-80023098 00B0+00 s=0 e=1 z=0 None .text * fpcNdRq_Request__FUliP18process_node_classsPvP32node_create_request_method_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNdRq_Request(u32 param_0, int param_1, process_node_class* param_2, s16 param_3, - void* param_4, node_create_request_method_class* param_5) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_Request__FUliP18process_node_classsPvP32node_create_request_method_class.s" +node_create_request* +fpcNdRq_Request(u32 param_1, int 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; } -#pragma pop /* 80023098-80023110 0078+00 s=1 e=0 z=0 None .text fpcNdRq_ReChangeNode__FUisPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcNdRq_ReChangeNode(unsigned int param_0, s16 param_1, void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_ReChangeNode__FUisPv.s" +s32 fpcNdRq_ReChangeNode(unsigned int pRequestId, s16 param_2, void* param_3) { + request_node_class* currentNode; + node_create_request* found; + currentNode = (request_node_class*)l_fpcNdRq_Queue.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((¤tNode->mBase)); + } + return 0; } -#pragma pop /* 80023110-80023130 0020+00 s=0 e=1 z=0 None .text fpcNdRq_ReRequest__FUisPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcNdRq_ReRequest(unsigned int param_0, s16 param_1, void* param_2) { - nofralloc -#include "asm/f_pc/f_pc_node_req/fpcNdRq_ReRequest__FUisPv.s" +s32 fpcNdRq_ReRequest(unsigned int pRequestId, s16 param_2, void* param_3) { + return fpcNdRq_ReChangeNode(pRequestId, param_2, param_3); } -#pragma pop diff --git a/src/f_pc/f_pc_pause.cpp b/src/f_pc/f_pc_pause.cpp index 1761eb9ee6..f3c6345f62 100644 --- a/src/f_pc/f_pc_pause.cpp +++ b/src/f_pc/f_pc_pause.cpp @@ -6,78 +6,58 @@ #include "f_pc/f_pc_pause.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct layer_class {}; - -// -// Forward References: -// - -void fpcPause_IsEnable(void*, u8); -void fpcPause_Enable(void*, u8); -void fpcPause_Disable(void*, u8); -void fpcPause_Init(void*); - -extern "C" void fpcPause_IsEnable__FPvUc(); -extern "C" void fpcPause_Enable__FPvUc(); -extern "C" void fpcPause_Disable__FPvUc(); -extern "C" void fpcPause_Init__FPv(); - -// -// External References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcLyIt_OnlyHere(layer_class*, int (*)(void*, void*), void*); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcLyIt_OnlyHere__FP11layer_classPFPvPv_iPv(); -extern "C" extern u8 g_fpcNd_type[4 + 4 /* padding */]; +#include "f_pc/f_pc_layer_iter.h" // // Declarations: // /* 80023844-80023868 0024+00 s=0 e=3 z=0 None .text fpcPause_IsEnable__FPvUc */ +#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 #pragma push #pragma optimization_level 0 #pragma optimizewithasm off -asm void fpcPause_IsEnable(void* param_0, u8 param_1) { +asm s32 fpcPause_IsEnable(void* param_0, u8 param_1) { nofralloc #include "asm/f_pc/f_pc_pause/fpcPause_IsEnable__FPvUc.s" } #pragma pop +#endif /* 80023868-800238D4 006C+00 s=0 e=1 z=0 None .text fpcPause_Enable__FPvUc */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPause_Enable(void* param_0, u8 param_1) { - nofralloc -#include "asm/f_pc/f_pc_pause/fpcPause_Enable__FPvUc.s" +s32 fpcPause_Enable(void* pProcess, u8 flag) { + base_process_class* pProc = (base_process_class*)pProcess; + pProc->mPauseFlag |= flag; + + if (fpcBs_Is_JustOfType(g_fpcNd_type, pProc->mSubType)) { + process_node_class* pNode = (process_node_class*)pProc; + fpcLyIt_OnlyHere(&pNode->mLayer, (fpcLyIt_OnlyHereFunc)fpcPause_Enable, + (void*)(flag & 0xFF)); + } + return 1; } -#pragma pop /* 800238D4-80023948 0074+00 s=0 e=1 z=0 None .text fpcPause_Disable__FPvUc */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPause_Disable(void* param_0, u8 param_1) { - nofralloc -#include "asm/f_pc/f_pc_pause/fpcPause_Disable__FPvUc.s" +s32 fpcPause_Disable(void* pProcess, u8 flag) { + base_process_class* pProc = (base_process_class*)pProcess; + pProc->mPauseFlag &= (0xFF - flag) & 0xFF; + + if (fpcBs_Is_JustOfType(g_fpcNd_type, pProc->mSubType)) { + process_node_class* pNode = (process_node_class*)pProc; + fpcLyIt_OnlyHere(&pNode->mLayer, (fpcLyIt_OnlyHereFunc)fpcPause_Disable, (void*)flag); + } + + return 1; } -#pragma pop /* 80023948-80023954 000C+00 s=0 e=1 z=0 None .text fpcPause_Init__FPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPause_Init(void* param_0) { - nofralloc -#include "asm/f_pc/f_pc_pause/fpcPause_Init__FPv.s" +void fpcPause_Init(void* pProcess) { + base_process_class* pProc = (base_process_class*)pProcess; + pProc->mPauseFlag = 0; } -#pragma pop diff --git a/src/f_pc/f_pc_priority.cpp b/src/f_pc/f_pc_priority.cpp index 472de25b31..644cf19999 100644 --- a/src/f_pc/f_pc_priority.cpp +++ b/src/f_pc/f_pc_priority.cpp @@ -6,81 +6,9 @@ #include "f_pc/f_pc_priority.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct process_priority_class {}; - -struct process_method_tag_class {}; - -struct node_list_class {}; - -struct line_tag {}; - -struct layer_management_tag_class {}; - -struct layer_class {}; - -struct create_tag_class {}; - -// -// Forward References: -// - -void fpcPi_IsInQueue(process_priority_class*); -static void fpcPi_QueueTo(process_priority_class*); -static void fpcPi_ToQueue(process_priority_class*); -static void fpcPi_GetFromQueue(); -void fpcPi_Delete(process_priority_class*); -static void fpcPi_IsNormal(unsigned int, u16, u16); -void fpcPi_Change(process_priority_class*, unsigned int, u16, u16); -void fpcPi_Handler(); -void fpcPi_Init(process_priority_class*, void*, unsigned int, u16, u16); - -extern "C" void fpcPi_IsInQueue__FP22process_priority_class(); -extern "C" static void fpcPi_QueueTo__FP22process_priority_class(); -extern "C" static void fpcPi_ToQueue__FP22process_priority_class(); -extern "C" static void fpcPi_GetFromQueue__Fv(); -extern "C" void fpcPi_Delete__FP22process_priority_class(); -extern "C" static void fpcPi_IsNormal__FUiUsUs(); -extern "C" void fpcPi_Change__FP22process_priority_classUiUsUs(); -extern "C" void fpcPi_Handler__Fv(); -extern "C" void fpcPi_Init__FP22process_priority_classPvUiUsUs(); -extern "C" extern u8 data_804505F0[8]; - -// -// External References: -// - -void fpcLy_CancelQTo(process_method_tag_class*); -void fpcLy_ToCancelQ(layer_class*, process_method_tag_class*); -void fpcLy_Layer(unsigned int); -void fpcLyTg_Move(layer_management_tag_class*, unsigned int, u16, u16); -void fpcLnTg_Move(line_tag*, int); -void fpcMtdTg_Init(process_method_tag_class*, int (*)(void*), void*); -void cTg_IsUse(create_tag_class*); -void cTg_GetFirst(node_list_class*); -void cTg_SingleCut(create_tag_class*); -void cTg_Addition(node_list_class*, create_tag_class*); -void cTg_Create(create_tag_class*, void*); - -extern "C" void fpcLy_CancelQTo__FP24process_method_tag_class(); -extern "C" void fpcLy_ToCancelQ__FP11layer_classP24process_method_tag_class(); -extern "C" void fpcLy_Layer__FUi(); -extern "C" void fpcLyTg_Move__FP26layer_management_tag_classUiUsUs(); -extern "C" void fpcLnTg_Move__FP8line_tagi(); -extern "C" void fpcMtdTg_Init__FP24process_method_tag_classPFPv_iPv(); -extern "C" void cTg_IsUse__FP16create_tag_class(); -extern "C" void cTg_GetFirst__FP15node_list_class(); -extern "C" void cTg_SingleCut__FP16create_tag_class(); -extern "C" void cTg_Addition__FP15node_list_classP16create_tag_class(); -extern "C" void cTg_Create__FP16create_tag_classPv(); -extern "C" void _savegpr_26(); -extern "C" void _savegpr_27(); -extern "C" void _restgpr_26(); -extern "C" void _restgpr_27(); +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_layer.h" +#include "f_pc/f_pc_layer_tag.h" // // Declarations: @@ -88,111 +16,166 @@ extern "C" void _restgpr_27(); /* 80023130-80023150 0020+00 s=0 e=1 z=0 None .text fpcPi_IsInQueue__FP22process_priority_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPi_IsInQueue(process_priority_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_IsInQueue__FP22process_priority_class.s" +s32 fpcPi_IsInQueue(process_priority_class* pPi) { + return cTg_IsUse(&pPi->mBase); } -#pragma pop /* 80023150-80023188 0038+00 s=1 e=0 z=0 None .text fpcPi_QueueTo__FP22process_priority_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcPi_QueueTo(process_priority_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_QueueTo__FP22process_priority_class.s" +s32 fpcPi_QueueTo(process_priority_class* pPi) { + cTg_SingleCut(&pPi->mBase); + fpcLy_CancelQTo(&pPi->mMtdTag); + return 1; } -#pragma pop /* ############################################################################################## */ /* 803F4E58-803F4E68 000C+04 s=2 e=0 z=0 None .bss l_fpcPi_Queue */ -static u8 l_fpcPi_Queue[12 + 4 /* padding */]; +static node_list_class l_fpcPi_Queue; /* 80023188-80023214 008C+00 s=1 e=0 z=0 None .text fpcPi_ToQueue__FP22process_priority_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcPi_ToQueue(process_priority_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_ToQueue__FP22process_priority_class.s" +s32 fpcPi_ToQueue(process_priority_class* pPi) { + u32 layer = pPi->mInfoQ.mLayer; + + if (cTg_Addition(&l_fpcPi_Queue, &pPi->mBase)) { + if (layer != 0xFFFFFFFD) { + layer_class* pLayer = fpcLy_Layer(layer); + + if (!fpcLy_ToCancelQ(pLayer, &pPi->mMtdTag)) { + cTg_SingleCut(&pPi->mBase); + return 0; + } + } + + return 1; + } + + return 0; } -#pragma pop /* 80023214-80023268 0054+00 s=1 e=0 z=0 None .text fpcPi_GetFromQueue__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcPi_GetFromQueue() { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_GetFromQueue__Fv.s" +process_priority_class* fpcPi_GetFromQueue(void) { + process_priority_class* pPi = (process_priority_class*)cTg_GetFirst(&l_fpcPi_Queue); + + if (pPi != NULL) { + base_process_class* pProc = (base_process_class*)pPi->mBase.mpTagData; + process_priority_class* pProcPi = &pProc->mPi; + fpcLy_CancelQTo(&pProcPi->mMtdTag); + return pProcPi; + } + + return NULL; } -#pragma pop /* ############################################################################################## */ /* 804505E8-804505F0 0008+00 s=1 e=0 z=0 None .sdata crear$2224 */ -SECTION_SDATA static u8 crear[8] = { - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +static process_priority_queue_info crear = { + 0xFFFFFFFF, + 0xFFFF, + 0xFFFF, }; /* 80023268-800232B4 004C+00 s=1 e=1 z=0 None .text fpcPi_Delete__FP22process_priority_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPi_Delete(process_priority_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_Delete__FP22process_priority_class.s" +s32 fpcPi_Delete(process_priority_class* pPi) { + fpcPi_QueueTo(pPi); + pPi->mInfoQ.mLayer = crear.mLayer; + pPi->mInfoQ.mListID = crear.mListID; + pPi->mInfoQ.mListPrio = crear.mListPrio; + return 1; } -#pragma pop /* 800232B4-800232E8 0034+00 s=2 e=0 z=0 None .text fpcPi_IsNormal__FUiUsUs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm static void fpcPi_IsNormal(unsigned int param_0, u16 param_1, u16 param_2) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_IsNormal__FUiUsUs.s" +s32 fpcPi_IsNormal(unsigned int layer, u16 listID, u16 priority) { + if ((layer < 0xFFFFFFFE) && (listID < 0xFFFE) && (priority < 0xFFFE)) + return 1; + + return 0; } -#pragma pop /* 800232E8-80023428 0140+00 s=0 e=3 z=0 None .text * fpcPi_Change__FP22process_priority_classUiUsUs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPi_Change(process_priority_class* param_0, unsigned int param_1, u16 param_2, - u16 param_3) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_Change__FP22process_priority_classUiUsUs.s" +s32 fpcPi_Change(process_priority_class* pPi, unsigned int layer, u16 listID, u16 priority) { + base_process_class* pProc = (base_process_class*)pPi->mBase.mpTagData; + BOOL changed = 0; + + if (pProc->mInitState == 3) + return 0; + + if (!fpcPi_IsNormal(layer, listID, priority)) + return 0; + + 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; + changed = 1; + } + + if (listID != 0xFFFD && pPi->mInfoCurr.mListID != listID) { + pPi->mInfoQ.mListID = listID; + changed = 1; + } + + if (priority != 0xFFFD && pPi->mInfoCurr.mListPrio != priority) { + pPi->mInfoQ.mListPrio = priority; + changed = 1; + } + + if (pProc->mInitState == 0 || pProc->mInitState == 1) { + pPi->mInfoCurr.mLayer = pPi->mInfoQ.mLayer; + pPi->mInfoCurr.mListID = pPi->mInfoQ.mListID; + pPi->mInfoCurr.mListPrio = pPi->mInfoQ.mListPrio; + return 1; + } + + if (changed == 1) + return fpcPi_ToQueue(pPi); + else + return 0; } -#pragma pop /* 80023428-800234BC 0094+00 s=0 e=1 z=0 None .text fpcPi_Handler__Fv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPi_Handler() { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_Handler__Fv.s" +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.mLayer = pPi->mInfoQ.mLayer; + pPi->mInfoCurr.mListID = pPi->mInfoQ.mListID; + pPi->mInfoCurr.mListPrio = pPi->mInfoQ.mListPrio; + } else { + return 0; + } + } + + return 1; } -#pragma pop /* 800234BC-80023564 00A8+00 s=0 e=1 z=0 None .text * fpcPi_Init__FP22process_priority_classPvUiUsUs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPi_Init(process_priority_class* param_0, void* param_1, unsigned int param_2, - u16 param_3, u16 param_4) { - nofralloc -#include "asm/f_pc/f_pc_priority/fpcPi_Init__FP22process_priority_classPvUiUsUs.s" +s32 fpcPi_Init(process_priority_class* pPi, void* pUserData, unsigned int 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.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; } -#pragma pop /* ############################################################################################## */ /* 804505F0-804505F8 0008+00 s=0 e=5 z=1 None .sdata None */ diff --git a/src/f_pc/f_pc_profile.cpp b/src/f_pc/f_pc_profile.cpp index 48a463e1db..6f4ecd45fa 100644 --- a/src/f_pc/f_pc_profile.cpp +++ b/src/f_pc/f_pc_profile.cpp @@ -7,33 +7,11 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Forward References: -// - -void fpcPf_Get(s16); - -extern "C" void fpcPf_Get__Fs(); -extern "C" extern u8 g_fpcPf_ProfileList_p[4 + 4 /* padding */]; - -// -// External References: -// - -// -// Declarations: -// - /* ############################################################################################## */ /* 80450D50-80450D58 0004+04 s=1 e=0 z=2 None .sbss g_fpcPf_ProfileList_p */ -u8 g_fpcPf_ProfileList_p[4 + 4 /* padding */]; +process_profile_definition** g_fpcPf_ProfileList_p; /* 80023564-80023578 0014+00 s=0 e=1 z=0 None .text fpcPf_Get__Fs */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcPf_Get(s16 param_0) { - nofralloc -#include "asm/f_pc/f_pc_profile/fpcPf_Get__Fs.s" +process_profile_definition* fpcPf_Get(s16 profileID) { + return g_fpcPf_ProfileList_p[profileID]; } -#pragma pop diff --git a/src/f_pc/f_pc_searcher.cpp b/src/f_pc/f_pc_searcher.cpp index 9febd90afd..3eef07bbf0 100644 --- a/src/f_pc/f_pc_searcher.cpp +++ b/src/f_pc/f_pc_searcher.cpp @@ -7,40 +7,22 @@ #include "dol2asm.h" #include "dolphin/types.h" -// -// Forward References: -// - -void fpcSch_JudgeForPName(void*, void*); -void fpcSch_JudgeByID(void*, void*); - -extern "C" void fpcSch_JudgeForPName__FPvPv(); -extern "C" void fpcSch_JudgeByID__FPvPv(); - -// -// External References: -// - // // Declarations: // /* 80023578-80023590 0018+00 s=0 e=3 z=77 None .text fpcSch_JudgeForPName__FPvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSch_JudgeForPName(void* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_searcher/fpcSch_JudgeForPName__FPvPv.s" +void* fpcSch_JudgeForPName(void* pProc, void* pUserData) { + s16 pname = *(s16*)pUserData; + if (((base_process_class*)pProc)->mProcName == pname) + return pProc; + return NULL; } -#pragma pop /* 80023590-800235A8 0018+00 s=0 e=44 z=270 None .text fpcSch_JudgeByID__FPvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSch_JudgeByID(void* param_0, void* param_1) { - nofralloc -#include "asm/f_pc/f_pc_searcher/fpcSch_JudgeByID__FPvPv.s" +void* fpcSch_JudgeByID(void* pProc, void* pUserData) { + s32 id = *(s32*)pUserData; + if (((base_process_class*)pProc)->mBsPcId == id) + return pProc; + return NULL; } -#pragma pop diff --git a/src/f_pc/f_pc_stdcreate_req.cpp b/src/f_pc/f_pc_stdcreate_req.cpp index c41ae83353..16f12625d3 100644 --- a/src/f_pc/f_pc_stdcreate_req.cpp +++ b/src/f_pc/f_pc_stdcreate_req.cpp @@ -6,75 +6,9 @@ #include "f_pc/f_pc_stdcreate_req.h" #include "dol2asm.h" #include "dolphin/types.h" - -// -// Types: -// - -struct standard_create_request_class {}; - -struct request_of_phase_process_class {}; - -struct layer_class {}; - -struct create_request_method_class {}; - -struct base_process_class {}; - -// -// Forward References: -// - -void fpcSCtRq_phase_Load(standard_create_request_class*); -void fpcSCtRq_phase_CreateProcess(standard_create_request_class*); -void fpcSCtRq_phase_SubCreateProcess(standard_create_request_class*); -void fpcSCtRq_phase_IsComplete(standard_create_request_class*); -void fpcSCtRq_phase_PostMethod(standard_create_request_class*); -static s32 fpcSCtRq_phase_Done(standard_create_request_class*); -void fpcSCtRq_Handler(standard_create_request_class*); -static bool fpcSCtRq_Delete(standard_create_request_class*); -bool fpcSCtRq_Cancel(standard_create_request_class*); -void fpcSCtRq_Request(layer_class*, s16, int (*)(void*, void*), void*, void*); - -extern "C" void fpcSCtRq_phase_Load__FP29standard_create_request_class(); -extern "C" void fpcSCtRq_phase_CreateProcess__FP29standard_create_request_class(); -extern "C" void fpcSCtRq_phase_SubCreateProcess__FP29standard_create_request_class(); -extern "C" void fpcSCtRq_phase_IsComplete__FP29standard_create_request_class(); -extern "C" void fpcSCtRq_phase_PostMethod__FP29standard_create_request_class(); -extern "C" static s32 fpcSCtRq_phase_Done__FP29standard_create_request_class(); -extern "C" void fpcSCtRq_Handler__FP29standard_create_request_class(); -extern "C" static bool fpcSCtRq_Delete__FP29standard_create_request_class(); -extern "C" bool fpcSCtRq_Cancel__FP29standard_create_request_class(); -extern "C" void fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv(); - -// -// External References: -// - -void fpcBs_Is_JustOfType(int, int); -void fpcBs_Create(s16, unsigned int, void*); -void fpcBs_SubCreate(base_process_class*); -void fpcCtRq_Create(layer_class*, u32, create_request_method_class*); -void fpcLy_IsCreatingMesg(layer_class*); -void fpcLy_SetCurrentLayer(layer_class*); -void fpcLd_Free(s16); -void fpcLd_Load(s16); -void cPhs_Set(request_of_phase_process_class*, int (**)(void*)); -void cPhs_Do(request_of_phase_process_class*, void*); - -extern "C" void fpcBs_Is_JustOfType__Fii(); -extern "C" void fpcBs_Create__FsUiPv(); -extern "C" void fpcBs_SubCreate__FP18base_process_class(); -extern "C" void fpcCtRq_Create__FP11layer_classUlP27create_request_method_class(); -extern "C" void fpcLy_IsCreatingMesg__FP11layer_class(); -extern "C" void fpcLy_SetCurrentLayer__FP11layer_class(); -extern "C" void fpcLd_Free__Fs(); -extern "C" void fpcLd_Load__Fs(); -extern "C" void cPhs_Set__FP30request_of_phase_process_classPPFPv_i(); -extern "C" void cPhs_Do__FP30request_of_phase_process_classPv(); -extern "C" void _savegpr_27(); -extern "C" void _restgpr_27(); -extern "C" extern u8 g_fpcNd_type[4 + 4 /* padding */]; +#include "f_pc/f_pc_load.h" +#include "f_pc/f_pc_base.h" +#include "f_pc/f_pc_node.h" // // Declarations: @@ -82,115 +16,134 @@ extern "C" extern u8 g_fpcNd_type[4 + 4 /* padding */]; /* 80023B70-80023BC4 0054+00 s=1 e=0 z=5 None .text * fpcSCtRq_phase_Load__FP29standard_create_request_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_phase_Load(standard_create_request_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_phase_Load__FP29standard_create_request_class.s" +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; + } } -#pragma pop /* 80023BC4-80023C2C 0068+00 s=1 e=0 z=9 None .text * fpcSCtRq_phase_CreateProcess__FP29standard_create_request_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_phase_CreateProcess(standard_create_request_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_phase_CreateProcess__FP29standard_create_request_class.s" +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; + } } -#pragma pop /* 80023C2C-80023C64 0038+00 s=1 e=0 z=3 None .text * fpcSCtRq_phase_SubCreateProcess__FP29standard_create_request_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_phase_SubCreateProcess__FP29standard_create_request_class.s" +s32 fpcSCtRq_phase_SubCreateProcess(standard_create_request_class* pStdCreateReq) { + fpcLy_SetCurrentLayer(pStdCreateReq->mBase.mpLayer); + return fpcBs_SubCreate(pStdCreateReq->mBase.mpRes); } -#pragma pop /* 80023C64-80023CBC 0058+00 s=1 e=0 z=14 None .text * fpcSCtRq_phase_IsComplete__FP29standard_create_request_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_phase_IsComplete(standard_create_request_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_phase_IsComplete__FP29standard_create_request_class.s" +s32 fpcSCtRq_phase_IsComplete(standard_create_request_class* pStdCreateReq) { + process_node_class* procNode = (process_node_class*)pStdCreateReq->mBase.mpRes; + if (fpcBs_Is_JustOfType(g_fpcNd_type, procNode->mBase.mSubType) == 1) { + if (fpcLy_IsCreatingMesg(&procNode->mLayer) == 1) { + return cPhs_ZERO_e; + } + } + return 2; } -#pragma pop /* 80023CBC-80023D0C 0050+00 s=1 e=0 z=5 None .text * fpcSCtRq_phase_PostMethod__FP29standard_create_request_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_phase_PostMethod(standard_create_request_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_phase_PostMethod__FP29standard_create_request_class.s" +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; + } } -#pragma pop /* 80023D0C-80023D14 0008+00 s=1 e=0 z=0 None .text * fpcSCtRq_phase_Done__FP29standard_create_request_class */ -static s32 fpcSCtRq_phase_Done(standard_create_request_class* param_0) { +s32 fpcSCtRq_phase_Done(standard_create_request_class* param_0) { return 2; } /* 80023D14-80023D84 0070+00 s=1 e=0 z=2 None .text * fpcSCtRq_Handler__FP29standard_create_request_class */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_Handler(standard_create_request_class* param_0) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_Handler__FP29standard_create_request_class.s" +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; + } } -#pragma pop /* 80023D84-80023D8C 0008+00 s=1 e=0 z=0 None .text * fpcSCtRq_Delete__FP29standard_create_request_class */ -static bool fpcSCtRq_Delete(standard_create_request_class* param_0) { - return true; +s32 fpcSCtRq_Delete(standard_create_request_class* param_0) { + return 1; } /* 80023D8C-80023D94 0008+00 s=1 e=0 z=1 None .text * fpcSCtRq_Cancel__FP29standard_create_request_class */ -bool fpcSCtRq_Cancel(standard_create_request_class* param_0) { - return true; +s32 fpcSCtRq_Cancel(standard_create_request_class* param_0) { + return 1; } /* ############################################################################################## */ /* 803A3AF0-803A3AFC 000C+00 s=1 e=0 z=0 None .data submethod$2261 */ -SECTION_DATA static void* submethod[3] = { - (void*)fpcSCtRq_Handler__FP29standard_create_request_class, - (void*)fpcSCtRq_Cancel__FP29standard_create_request_class, - (void*)fpcSCtRq_Delete__FP29standard_create_request_class, +static create_request_method_class submethod = { + (cPhs__Handler)fpcSCtRq_Handler, + (process_method_func)fpcSCtRq_Cancel, + (process_method_func)fpcSCtRq_Delete, }; /* 803A3AFC-803A3B18 001C+00 s=1 e=0 z=0 None .data method$2262 */ -SECTION_DATA static void* method[7] = { - (void*)fpcSCtRq_phase_Load__FP29standard_create_request_class, - (void*)fpcSCtRq_phase_CreateProcess__FP29standard_create_request_class, - (void*)fpcSCtRq_phase_SubCreateProcess__FP29standard_create_request_class, - (void*)fpcSCtRq_phase_IsComplete__FP29standard_create_request_class, - (void*)fpcSCtRq_phase_PostMethod__FP29standard_create_request_class, - (void*)fpcSCtRq_phase_Done__FP29standard_create_request_class, - (void*)NULL, +static cPhs__Handler method[7] = { + (cPhs__Handler)fpcSCtRq_phase_Load, + (cPhs__Handler)fpcSCtRq_phase_CreateProcess, + (cPhs__Handler)fpcSCtRq_phase_SubCreateProcess, + (cPhs__Handler)fpcSCtRq_phase_IsComplete, + (cPhs__Handler)fpcSCtRq_phase_PostMethod, + (cPhs__Handler)fpcSCtRq_phase_Done, + NULL, }; /* 80023D94-80023E28 0094+00 s=0 e=12 z=1 None .text * fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv */ -#pragma push -#pragma optimization_level 0 -#pragma optimizewithasm off -asm void fpcSCtRq_Request(layer_class* param_0, s16 param_1, int (*)(void*, void*), void* param_3, - void* param_4) { - nofralloc -#include "asm/f_pc/f_pc_stdcreate_req/fpcSCtRq_Request__FP11layer_classsPFPvPv_iPvPv.s" +s32 fpcSCtRq_Request(layer_class* param_1, s16 pProcName, stdCreateFunc param_3, void* param_4, + void* param_5) { + if (pProcName >= 0x7FFF) { + return -1; + } else { + standard_create_request_class* request = + (standard_create_request_class*)fpcCtRq_Create(param_1, 0x60, &submethod); + if (request == NULL) { + return -1; + } else { + cPhs_Set(&request->unk_0x48, method); + request->mLoadID = pProcName; + request->unk_0x58 = param_3; + request->unk_0x5C = param_4; + request->unk_0x54 = param_5; + return request->mBase.mBsPcId; + } + } } -#pragma pop