mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-08-16 12:24:45 -04:00
some f_op
This commit is contained in:
lepelog
+114
-112
@@ -4,21 +4,12 @@
|
||||
//
|
||||
|
||||
#include "f_op/f_op_overlap_req.h"
|
||||
#include "f_pc/f_pc_executor.h"
|
||||
#include "f_pc/f_pc_manager.h"
|
||||
#include "f_pc/f_pc_stdcreate_req.h"
|
||||
#include "dol2asm.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
//
|
||||
// Types:
|
||||
//
|
||||
|
||||
struct request_of_phase_process_class {};
|
||||
|
||||
struct request_base_class {};
|
||||
|
||||
struct overlap_request_class {};
|
||||
|
||||
struct layer_class {};
|
||||
|
||||
//
|
||||
// Forward References:
|
||||
//
|
||||
@@ -57,162 +48,173 @@ extern "C" void cReq_Create__FP18request_base_classUc();
|
||||
extern "C" void _savegpr_29();
|
||||
extern "C" void _restgpr_29();
|
||||
|
||||
void fopOvlpReq_SetPeektime(overlap_request_class*, u16);
|
||||
|
||||
//
|
||||
// Declarations:
|
||||
//
|
||||
|
||||
/* 8001E6EC-8001E748 01902C 005C+00 2/1 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_Done__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_Done(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_Done__FP21overlap_request_class.s"
|
||||
static int fopOvlpReq_phase_Done(overlap_request_class* pOvlpReq) {
|
||||
if (fpcM_Delete(pOvlpReq->field_0x20) == 1) {
|
||||
pOvlpReq->field_0x20 = 0;
|
||||
pOvlpReq->field_0x4 = 0;
|
||||
pOvlpReq->mPeektime = 0;
|
||||
pOvlpReq->field_0x8 = 0;
|
||||
pOvlpReq->field_0xc = 0;
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E748-8001E794 019088 004C+00 1/0 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_IsDone__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_IsDone(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_IsDone__FP21overlap_request_class.s"
|
||||
static s32 fopOvlpReq_phase_IsDone(overlap_request_class* param_1) {
|
||||
cReq_Done((request_base_class*)param_1);
|
||||
return param_1->field_0x2-- <= 0 ? 2 : 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E794-8001E7E4 0190D4 0050+00 1/0 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_IsWaitOfFadeout__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_IsWaitOfFadeout(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_IsWaitOfFadeout__FP21overlap_request_class.s"
|
||||
static int fopOvlpReq_phase_IsWaitOfFadeout(overlap_request_class* pOvlpReq) {
|
||||
if (cReq_Is_Done((request_base_class*)(pOvlpReq->field_0x20 + 0xC4))) {
|
||||
pOvlpReq->field_0x8 = 0;
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E7E4-8001E854 019124 0070+00 1/0 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_WaitOfFadeout__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_WaitOfFadeout(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_WaitOfFadeout__FP21overlap_request_class.s"
|
||||
static int fopOvlpReq_phase_WaitOfFadeout(overlap_request_class* pOvlpReq) {
|
||||
if (pOvlpReq->mPeektime) {
|
||||
pOvlpReq->mPeektime--;
|
||||
}
|
||||
|
||||
if (((u8)(pOvlpReq->field_0x0 & 0x3F)) == 2 && !pOvlpReq->mPeektime) {
|
||||
cReq_Command((request_base_class*)(pOvlpReq->field_0x20 + 0xC4), 2);
|
||||
return 2;
|
||||
}
|
||||
|
||||
pOvlpReq->field_0x8 = 1;
|
||||
return 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E854-8001E8A4 019194 0050+00 1/0 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_IsComplete__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_IsComplete(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_IsComplete__FP21overlap_request_class.s"
|
||||
static int fopOvlpReq_phase_IsComplete(overlap_request_class* pOvlpReq) {
|
||||
if (cReq_Is_Done((request_base_class*)(pOvlpReq->field_0x20 + 0xC4))) {
|
||||
cReq_Done((request_base_class*)pOvlpReq);
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E8A4-8001E904 0191E4 0060+00 1/0 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_IsCreated__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_IsCreated(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_IsCreated__FP21overlap_request_class.s"
|
||||
static int fopOvlpReq_phase_IsCreated(overlap_request_class* pOvlpReq) {
|
||||
if (fpcM_IsCreating(pOvlpReq->field_0x14) == 0) {
|
||||
base_process_class* pBaseProc = fpcEx_SearchByID(pOvlpReq->field_0x14);
|
||||
if (!pBaseProc) {
|
||||
return 5;
|
||||
}
|
||||
pOvlpReq->field_0x20 = (u8*)pBaseProc;
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E904-8001E954 019244 0050+00 1/0 0/0 0/0 .text
|
||||
* fopOvlpReq_phase_Create__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_phase_Create(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_phase_Create__FP21overlap_request_class.s"
|
||||
static int fopOvlpReq_phase_Create(overlap_request_class* pOvlpReq) {
|
||||
fpcLy_SetCurrentLayer(pOvlpReq->pCurrentLayer);
|
||||
pOvlpReq->field_0x14 = fpcSCtRq_Request(fpcLy_CurrentLayer(), pOvlpReq->field_0x10, 0, 0, 0);
|
||||
return 2;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* ############################################################################################## */
|
||||
/* 803A3890-803A38B0 -00001 0020+00 1/1 0/0 0/0 .data phaseMethod$2260 */
|
||||
SECTION_DATA static void* phaseMethod[8] = {
|
||||
(void*)fopOvlpReq_phase_Create__FP21overlap_request_class,
|
||||
(void*)fopOvlpReq_phase_IsCreated__FP21overlap_request_class,
|
||||
(void*)fopOvlpReq_phase_IsComplete__FP21overlap_request_class,
|
||||
(void*)fopOvlpReq_phase_WaitOfFadeout__FP21overlap_request_class,
|
||||
(void*)fopOvlpReq_phase_IsWaitOfFadeout__FP21overlap_request_class,
|
||||
(void*)fopOvlpReq_phase_IsDone__FP21overlap_request_class,
|
||||
(void*)fopOvlpReq_phase_Done__FP21overlap_request_class,
|
||||
(void*)NULL,
|
||||
cPhs__Handler phaseMethod[8] = {
|
||||
(cPhs__Handler)fopOvlpReq_phase_Create,
|
||||
(cPhs__Handler)fopOvlpReq_phase_IsCreated,
|
||||
(cPhs__Handler)fopOvlpReq_phase_IsComplete,
|
||||
(cPhs__Handler)fopOvlpReq_phase_WaitOfFadeout,
|
||||
(cPhs__Handler)fopOvlpReq_phase_IsWaitOfFadeout,
|
||||
(cPhs__Handler)fopOvlpReq_phase_IsDone,
|
||||
(cPhs__Handler)fopOvlpReq_phase_Done,
|
||||
(cPhs__Handler)NULL,
|
||||
};
|
||||
|
||||
/* 8001E954-8001E9F0 019294 009C+00 0/0 1/1 0/0 .text
|
||||
* fopOvlpReq_Request__FP21overlap_request_classsUs */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
asm void fopOvlpReq_Request(overlap_request_class* param_0, s16 param_1, u16 param_2) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_Request__FP21overlap_request_classsUs.s"
|
||||
request_base_class* fopOvlpReq_Request(overlap_request_class* pOvlpReq, s16 param_2, u16 param_3) {
|
||||
if (pOvlpReq->field_0x4 == 1) {
|
||||
pOvlpReq = 0;
|
||||
return (request_base_class*)pOvlpReq;
|
||||
}
|
||||
|
||||
cReq_Command((request_base_class*)pOvlpReq, 1);
|
||||
pOvlpReq->field_0x10 = param_2;
|
||||
cPhs_Set(&pOvlpReq->field_0x18, phaseMethod);
|
||||
fopOvlpReq_SetPeektime(pOvlpReq, param_3);
|
||||
pOvlpReq->field_0x4 = 1;
|
||||
pOvlpReq->field_0x2 = 1;
|
||||
pOvlpReq->field_0x20 = 0;
|
||||
pOvlpReq->field_0x8 = 0;
|
||||
pOvlpReq->field_0xc = 0;
|
||||
pOvlpReq->pCurrentLayer = fpcLy_RootLayer();
|
||||
return (request_base_class*)pOvlpReq;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001E9F0-8001EA88 019330 0098+00 0/0 1/1 0/0 .text
|
||||
* fopOvlpReq_Handler__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
asm void fopOvlpReq_Handler(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_Handler__FP21overlap_request_class.s"
|
||||
int fopOvlpReq_Handler(overlap_request_class* pOvlpReq) {
|
||||
int phsDo = cPhs_Do(&pOvlpReq->field_0x18, pOvlpReq);
|
||||
switch (phsDo) {
|
||||
case 2:
|
||||
return fopOvlpReq_Handler(pOvlpReq);
|
||||
case 0:
|
||||
return 0;
|
||||
case 1:
|
||||
return 0;
|
||||
case 4:
|
||||
return 4;
|
||||
case 3:
|
||||
case 5:
|
||||
return 5;
|
||||
default:
|
||||
return 5;
|
||||
}
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001EA88-8001EAB4 0193C8 002C+00 0/0 1/1 0/0 .text fopOvlpReq_Cancel__FP21overlap_request_class
|
||||
*/
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
asm void fopOvlpReq_Cancel(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_Cancel__FP21overlap_request_class.s"
|
||||
int fopOvlpReq_Cancel(overlap_request_class* pOvlpReq) {
|
||||
return fopOvlpReq_phase_Done(pOvlpReq) == 2 ? 1 : 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001EAB4-8001EAC4 0193F4 0010+00 1/1 0/0 0/0 .text
|
||||
* fopOvlpReq_Is_PeektimeLimit__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_Is_PeektimeLimit(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_Is_PeektimeLimit__FP21overlap_request_class.s"
|
||||
int fopOvlpReq_Is_PeektimeLimit(overlap_request_class* pOvlpReq) {
|
||||
return pOvlpReq->mPeektime == 0 ? 1 : 0;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001EAC4-8001EAD8 019404 0014+00 1/1 0/0 0/0 .text
|
||||
* fopOvlpReq_SetPeektime__FP21overlap_request_classUs */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
static asm void fopOvlpReq_SetPeektime(overlap_request_class* param_0, u16 param_1) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_SetPeektime__FP21overlap_request_classUs.s"
|
||||
void fopOvlpReq_SetPeektime(overlap_request_class* pOvlpReq, u16 param_2) {
|
||||
if (0x7fff < param_2) {
|
||||
return;
|
||||
}
|
||||
pOvlpReq->mPeektime = param_2;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
/* 8001EAD8-8001EB34 019418 005C+00 0/0 1/1 0/0 .text
|
||||
* fopOvlpReq_OverlapClr__FP21overlap_request_class */
|
||||
#pragma push
|
||||
#pragma optimization_level 0
|
||||
#pragma optimizewithasm off
|
||||
asm void fopOvlpReq_OverlapClr(overlap_request_class* param_0) {
|
||||
nofralloc
|
||||
#include "asm/f_op/f_op_overlap_req/fopOvlpReq_OverlapClr__FP21overlap_request_class.s"
|
||||
int fopOvlpReq_OverlapClr(overlap_request_class* pOvlpReq) {
|
||||
if ((u8)((pOvlpReq->field_0x0 >> 7) & 1) == 1 || !fopOvlpReq_Is_PeektimeLimit(pOvlpReq)) {
|
||||
return 0;
|
||||
}
|
||||
cReq_Create((request_base_class*)pOvlpReq, 2);
|
||||
return 1;
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
Reference in New Issue
Block a user