mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-05-23 06:54:28 -04:00
Code Issues Packages Projects Releases Wiki Activity

ported over f_pc

Browse Source
This commit is contained in:
lepelog
2021-04-01 12:06:29 +02:00
parent 87bc0e711b
commit 53c6aa6c8b
62 changed files with 2202 additions and 3049 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/SSystem/SStandard/s_basic.h
+3
View File
@@ -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 */
include/f_pc/f_pc_base.h
+50 -3
View File
@@ -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
include/f_pc/f_pc_create_iter.h
+31 -3
View File
@@ -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
include/f_pc/f_pc_create_req.h
+41 -3
View File
@@ -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
include/f_pc/f_pc_create_tag.h
+15 -3
View File
@@ -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
include/f_pc/f_pc_creator.h
+11 -3
View File
@@ -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
include/f_pc/f_pc_delete_tag.h
+22 -3
View File
@@ -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
include/f_pc/f_pc_deletor.h
+13 -4
View File
@@ -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
include/f_pc/f_pc_draw.h
+11 -3
View File
@@ -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
include/f_pc/f_pc_draw_priority.h
+12 -3
View File
@@ -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
include/f_pc/f_pc_executor.h
+21 -4
View File
@@ -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
include/f_pc/f_pc_fstcreate_req.h
+20 -3
View File
@@ -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
include/f_pc/f_pc_layer.h
+50 -3
View File
@@ -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
include/f_pc/f_pc_layer_iter.h
+18 -3
View File
@@ -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
include/f_pc/f_pc_layer_tag.h
+19 -3
View File
@@ -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
include/f_pc/f_pc_leaf.h
+38 -3
View File
@@ -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
include/f_pc/f_pc_line.h
+8 -4
View File
@@ -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
include/f_pc/f_pc_line_iter.h
+9 -4
View File
@@ -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
include/f_pc/f_pc_line_tag.h
+15 -3
View File
@@ -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
include/f_pc/f_pc_load.h
+9 -3
View File
@@ -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
include/f_pc/f_pc_manager.h
+33 -3
View File
@@ -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
include/f_pc/f_pc_method.h
+24 -3
View File
@@ -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
include/f_pc/f_pc_method_iter.h
+9 -3
View File
@@ -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
include/f_pc/f_pc_method_tag.h
+18 -3
View File
@@ -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
include/f_pc/f_pc_node.h
+39 -4
View File
@@ -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
include/f_pc/f_pc_node_req.h
+66 -3
View File
@@ -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
include/f_pc/f_pc_pause.h
+10 -3
View File
@@ -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
include/f_pc/f_pc_priority.h
+30 -4
View File
@@ -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
include/f_pc/f_pc_profile.h
+23 -3
View File
@@ -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
include/f_pc/f_pc_searcher.h
+12 -3
View File
@@ -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
include/f_pc/f_pc_stdcreate_req.h
+31 -3
View File
@@ -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
libs/SSystem/SStandard/s_basic.cpp
+8 -32
View File
@@ -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
src/f_pc/f_pc_base.cpp
+98 -156
View File
@@ -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
src/f_pc/f_pc_create_iter.cpp
+24 -75
View File
@@ -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<create_request*>(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
src/f_pc/f_pc_create_req.cpp
+100 -154
View File
@@ -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<create_request*>(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
src/f_pc/f_pc_create_tag.cpp
+8 -75
View File
@@ -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
src/f_pc/f_pc_creator.cpp
+10 -64
View File
@@ -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
src/f_pc/f_pc_delete_tag.cpp
+31 -91
View File
@@ -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
src/f_pc/f_pc_deletor.cpp
+87 -136
View File
@@ -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<base_process_class*>(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
src/f_pc/f_pc_draw.cpp
+27 -53
View File
@@ -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
src/f_pc/f_pc_draw_priority.cpp
+6 -43
View File
@@ -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
src/f_pc/f_pc_executor.cpp
+56 -121
View File
@@ -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
src/f_pc/f_pc_fstcreate_req.cpp
+40 -70
View File
@@ -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
src/f_pc/f_pc_layer.cpp
+105 -264
View File
@@ -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<process_node_class*>(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
src/f_pc/f_pc_layer_iter.cpp
+36 -80
View File
@@ -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(&current->mNodeListTree, (cNdIt_JudgeFunc)cTgIt_JudgeFilter, &lIter);
if (result != NULL) {
return result;
}
current = (layer_class*)current->mNode.mpNextNode;
}
return NULL;
}
#pragma pop
src/f_pc/f_pc_layer_tag.cpp
+62 -110
View File
@@ -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
src/f_pc/f_pc_leaf.cpp
+36 -118
View File
@@ -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];
src/f_pc/f_pc_line.cpp
+12 -34
View File
@@ -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),
};
src/f_pc/f_pc_line_iter.cpp
+21 -55
View File
@@ -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<base_process_class*>(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
src/f_pc/f_pc_line_tag.cpp
+23 -65
View File
@@ -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
src/f_pc/f_pc_load.cpp
+23 -53
View File
@@ -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
src/f_pc/f_pc_manager.cpp
+60 -122
View File
@@ -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
src/f_pc/f_pc_method.cpp
+13 -61
View File
@@ -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
src/f_pc/f_pc_method_iter.cpp
+2 -31
View File
@@ -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
src/f_pc/f_pc_method_tag.cpp
+11 -66
View File
@@ -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
src/f_pc/f_pc_node.cpp
+77 -144
View File
@@ -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<process_node_class*>(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,
};
src/f_pc/f_pc_node_req.cpp
+254 -295
View File
@@ -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((&currentNode->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((&currentNode->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((&currentNode->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
src/f_pc/f_pc_pause.cpp
+33 -53
View File
@@ -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
src/f_pc/f_pc_priority.cpp
+126 -143
View File
@@ -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 */
src/f_pc/f_pc_profile.cpp
+3 -25
View File
@@ -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
src/f_pc/f_pc_searcher.cpp
+10 -28
View File
@@ -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
src/f_pc/f_pc_stdcreate_req.cpp
+89 -136
View File
@@ -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