f_op debug 3

configure.py

@@ -634,7 +634,7 @@ config.libs = [
             Object(MatchingFor(ALL_GCN, "ShieldD"), "f_op/f_op_actor_tag.cpp"),
             Object(MatchingFor(ALL_GCN, "ShieldD"), "f_op/f_op_camera.cpp"),
             Object(MatchingFor(ALL_GCN), "f_op/f_op_actor_mng.cpp"),
-            Object(MatchingFor(ALL_GCN), "f_op/f_op_camera_mng.cpp"),
+            Object(MatchingFor(ALL_GCN), "f_op/f_op_camera_mng.cpp"), # ShieldD inlines
             Object(MatchingFor(ALL_GCN, "ShieldD"), "f_op/f_op_overlap.cpp"),
             Object(MatchingFor(ALL_GCN), "f_op/f_op_overlap_mng.cpp"),
             Object(MatchingFor(ALL_GCN, "ShieldD"), "f_op/f_op_overlap_req.cpp"),
@@ -643,8 +643,8 @@ config.libs = [
             Object(MatchingFor(ALL_GCN), "f_op/f_op_scene_mng.cpp"),
             Object(MatchingFor(ALL_GCN), "f_op/f_op_scene_req.cpp"),
             Object(MatchingFor(ALL_GCN, "ShieldD"), "f_op/f_op_scene_tag.cpp"),
-            Object(MatchingFor(ALL_GCN), "f_op/f_op_view.cpp"),
-            Object(MatchingFor(ALL_GCN), "f_op/f_op_kankyo.cpp"),
+            Object(MatchingFor(ALL_GCN, "ShieldD"), "f_op/f_op_view.cpp"),
+            Object(MatchingFor(ALL_GCN), "f_op/f_op_kankyo.cpp"), # ShieldD lbl_8074C510 undefined
             Object(MatchingFor(ALL_GCN), "f_op/f_op_msg.cpp"), # ShieldD fopMsg::MemCheck
             Object(MatchingFor(ALL_GCN), "f_op/f_op_kankyo_mng.cpp"),
             Object(MatchingFor(ALL_GCN), "f_op/f_op_msg_mng.cpp"),

include/f_op/f_op_kankyo.h

@@ -19,6 +19,8 @@ struct kankyo_process_profile_definition {
     /* 0x24 */ leafdraw_method_class* sub_method;
 };  // Size: 0x28
 
+void fopKy_IsKankyo(void* i_this);
+
 extern leafdraw_method_class g_fopKy_Method;
 
 #endif /* F_OP_F_OP_KANKYO_H */

include/f_op/f_op_scene_mng.h

@@ -1,6 +1,7 @@
 #ifndef F_F_OP_SCENE_MNG_H_
 #define F_F_OP_SCENE_MNG_H_
 
+#include "f_op/f_op_scene_pause.h"
 #include "f_pc/f_pc_manager.h"
 #include "f_op/f_op_scene.h"
 
@@ -32,4 +33,12 @@ inline u32 fopScnM_GetParam(void* i_scene) {
     return fpcM_GetParam(i_scene);
 }
 
+inline int fopScnM_PauseEnable(scene_class* i_scene) {
+    return fopScnPause_Enable(i_scene);
+}
+
+inline int fopScnM_PauseDisable(scene_class* i_scene) {
+    return fopScnPause_Disable(i_scene);
+}
+
 #endif

src/f_op/f_op_camera_mng.cpp

@@ -11,6 +11,10 @@ u32 fopCamM_GetParam(camera_class* i_this) {
     return fpcM_GetParam(i_this);
 }
 
+void dummy(fpc_ProcID i_procName) {
+    fpcM_SearchByID(i_procName);
+}
+
 fpc_ProcID fopCamM_Create(int i_cameraIdx, s16 i_procName, void* i_append) {
     l_fopCamM_id[i_cameraIdx] = fpcM_Create(i_procName, NULL, i_append);
     return l_fopCamM_id[i_cameraIdx];

src/f_op/f_op_kankyo.cpp

@@ -6,38 +6,56 @@
 #include "f_op/f_op_kankyo.h"
 #include "d/d_com_inf_game.h"
 #include "d/d_s_play.h"
+#include "f_ap/f_ap_game.h"
 #include "f_op/f_op_draw_tag.h"
 #include "f_op/f_op_kankyo_mng.h"
 
+static int fopKy_KANKYO_TYPE;
+// static int lbl_8074C510;
+
 static int fopKy_Draw(void* i_this) {
     int ret;
-    kankyo_class* a_this = (kankyo_class*)i_this;
+
+#if DEBUG
+    fapGm_HIO_c::startCpuTimer();
+#endif
 
     if (!dComIfGp_isPauseFlag()) {
-        ret = fpcLf_DrawMethod(a_this->sub_method, i_this);
+        ret = fpcLf_DrawMethod(((kankyo_class*)i_this)->sub_method, i_this);
     }
 
+#if DEBUG
+    fapGm_HIO_c::stopCpuTimer("環境関係（描画処理）"); // Environmental aspects (rendering processing)
+#endif
+
     return ret;
 }
 
 static int fopKy_Execute(void* i_this) {
-    int ret;
     kankyo_class* a_this = (kankyo_class*)i_this;
+    int ret;
+    
+#if DEBUG
+    fapGm_HIO_c::startCpuTimer();
+#endif
 
-    if (!dScnPly_c::isPause() && (!dComIfGp_isPauseFlag() || fpcM_GetName(i_this) == PROC_ENVSE)) {
-        ret = fpcMtd_Execute(&a_this->sub_method->base, i_this);
+    if (!dScnPly_c::isPause() && (!dComIfGp_isPauseFlag() || fpcM_GetName(a_this) == PROC_ENVSE)) {
+        ret = fpcMtd_Execute(&((kankyo_class*)i_this)->sub_method->base, i_this);
     }
 
+#if DEBUG
+    fapGm_HIO_c::stopCpuTimer("環境関係（計算処理）"); // Environmental aspects (computational processing)
+#endif
+
     return ret;
 }
 
 static int fopKy_IsDelete(void* i_this) {
     int ret;
-    kankyo_class* a_this = (kankyo_class*)i_this;
 
-    ret = fpcMtd_IsDelete(&a_this->sub_method->base, a_this);
+    ret = fpcMtd_IsDelete(&((kankyo_class*)i_this)->sub_method->base, i_this);
     if (ret == 1) {
-        fopDwTg_DrawQTo(&a_this->draw_tag);
+        fopDwTg_DrawQTo(&((kankyo_class*)i_this)->draw_tag);
     }
 
     return ret;
@@ -52,15 +70,14 @@ static int fopKy_Delete(void* i_this) {
     return ret;
 }
 
-static int fopKy_KANKYO_TYPE;
-
 static int fopKy_Create(void* i_this) {
     kankyo_class* a_this = (kankyo_class*)i_this;
+    int ret;
 
     if (fpcM_IsFirstCreating(i_this)) {
         kankyo_process_profile_definition* profile = (kankyo_process_profile_definition*)fpcM_GetProfile(i_this);
 
-        a_this->type = fpcBs_MakeOfType(&fopKy_KANKYO_TYPE);
+        a_this->type = fpcM_MakeOfType(&fopKy_KANKYO_TYPE);
         a_this->sub_method = profile->sub_method;
 
         fopDwTg_Init(&a_this->draw_tag, a_this);
@@ -73,10 +90,9 @@ static int fopKy_Create(void* i_this) {
         }
     }
 
-    int ret = fpcMtd_Create(&a_this->sub_method->base, a_this);
+    ret = fpcMtd_Create(&a_this->sub_method->base, a_this);
     if (ret == cPhs_COMPLEATE_e) {
-        s32 priority = fpcM_DrawPriority(a_this);
-        fopDwTg_ToDrawQ(&a_this->draw_tag, priority);
+        fopDwTg_ToDrawQ(&a_this->draw_tag, fpcM_DrawPriority(a_this));
     }
 
     return ret;

src/f_op/f_op_kankyo_mng.cpp

@@ -7,12 +7,22 @@
 #include "SSystem/SComponent/c_malloc.h"
 #include "d/d_com_inf_game.h"
 
+void dummy(fpcLyIt_JudgeFunc i_createFunc, void* i_this) {
+    fpcM_Search(i_createFunc, i_this);
+}
+
+void fopKyM_IsKy(void* i_this) {
+    fopKy_IsKankyo((fopKyM_prm_class*)i_this);
+}
+
 fopKyM_prm_class* fopKyM_CreateAppend() {
     fopKyM_prm_class* append = (fopKyM_prm_class*)cMl::memalignB(-4, sizeof(fopKyM_prm_class));
 
     if (append != NULL) {
         cLib_memSet(append, 0, sizeof(fopKyM_prm_class));
-        append->scale.set(1.0f, 1.0f, 1.0f);
+        append->scale.x = 1.0f;
+        append->scale.y = 1.0f;
+        append->scale.z = 1.0f;
     }
     return append;
 }
@@ -71,9 +81,7 @@ fpc_ProcID fopKyM_createWpillar(cXyz const* i_pos, f32 scale, int i_param) {
     }
 
     append->pos = *i_pos;
-    append->scale.x = scale;
-    append->scale.y = scale;
-    append->scale.z = scale;
+    append->scale.set(scale, scale, scale);
     append->parameters = i_param;
 
     return fopKyM_Create(PROC_WPILLAR, NULL, append);
@@ -86,9 +94,7 @@ fpc_ProcID fopKyM_createMpillar(cXyz const* i_pos, f32 i_size) {
     };
 
     cXyz scale;
-    scale.x = i_size;
-    scale.y = i_size;
-    scale.z = i_size;
+    scale.setall(i_size);
 
     for (int i = 0; i < 2; i++) {
         dComIfGp_particle_set(m_name[i], i_pos, NULL, &scale);

src/f_op/f_op_overlap_mng.cpp

@@ -4,29 +4,32 @@
  */
 
 #include "SSystem/SComponent/c_request.h"
+#include "m_Do/m_Do_controller_pad.h"
 #include "f_op/f_op_overlap_mng.h"
 #include "f_op/f_op_overlap_req.h"
+#include "f_op/f_op_scene_mng.h"
 #include "f_op/f_op_scene_pause.h"
-#include "f_pc/f_pc_executor.h"
 
 // making it not an array put it in .bss
 static overlap_request_class* l_fopOvlpM_overlap[1] = {NULL};
 
 int fopOvlpM_SceneIsStop() {
     if (l_fopOvlpM_overlap[0] != NULL) {
-        return fopScnPause_Enable(
-            (scene_class*)fpcEx_SearchByID(l_fopOvlpM_overlap[0]->overlap_task->scene_id));
+        fpc_ProcID scene_id = l_fopOvlpM_overlap[0]->overlap_task->scene_id;
+        scene_class* cls = (scene_class*)fpcM_SearchByID(scene_id);
+        return fopScnM_PauseEnable(cls);
     }
-    
+
     return 0;
 }
 
 int fopOvlpM_SceneIsStart() {
     if (l_fopOvlpM_overlap[0] != NULL) {
-        return fopScnPause_Disable(
-            (scene_class*)fpcEx_SearchByID(l_fopOvlpM_overlap[0]->overlap_task->scene_id));
+        fpc_ProcID scene_id = l_fopOvlpM_overlap[0]->overlap_task->scene_id;
+        scene_class* cls = (scene_class*)fpcM_SearchByID(scene_id);
+        return fopScnM_PauseDisable(cls);
     }
-    
+
     return 0;
 }
 
@@ -45,23 +48,31 @@ void fopOvlpM_ToldAboutID(fpc_ProcID i_sceneId) {
 }
 
 int fopOvlpM_IsPeek() {
-    return l_fopOvlpM_overlap[0] != NULL ? l_fopOvlpM_overlap[0]->field_0x8 : FALSE;
+    if (l_fopOvlpM_overlap[0] != NULL) {
+        return l_fopOvlpM_overlap[0]->field_0x8;
+    }
+    return FALSE;
 }
 
 int fopOvlpM_IsDone() {
-    return l_fopOvlpM_overlap[0] != NULL ? cReq_Is_Done(&l_fopOvlpM_overlap[0]->base) : FALSE;
+    if (l_fopOvlpM_overlap[0] != NULL) {
+        return cReq_Is_Done(&l_fopOvlpM_overlap[0]->base);
+    }
+    return FALSE;
 }
 
 int fopOvlpM_IsDoingReq() {
     if (l_fopOvlpM_overlap[0] != NULL && l_fopOvlpM_overlap[0]->field_0x4 == 1) {
         return 1;
     }
-
-    return 0;
+    return FALSE;
 }
 
 int fopOvlpM_ClearOfReq() {
-    return l_fopOvlpM_overlap[0] != NULL ? fopOvlpReq_OverlapClr(l_fopOvlpM_overlap[0]) : 0;
+    if (l_fopOvlpM_overlap[0] != NULL) {
+        return fopOvlpReq_OverlapClr(l_fopOvlpM_overlap[0]);
+    }
+    return FALSE;
 }
 
 static overlap_request_class l_fopOvlpM_Request;
@@ -94,6 +105,12 @@ int fopOvlpM_Cancel() {
 
     if (fopOvlpReq_Cancel(l_fopOvlpM_overlap[0]) == true) {
         l_fopOvlpM_overlap[0] = NULL;
+#if DEBUG
+        BOOL state = mDoCPd_c::isConnect(PAD_3);
+        if (state) {
+            JUT_WARN(336, "%s", "fopOvlpM_Cancel SUCCESSED");
+        }
+#endif
         return 1;
     }
 

src/f_op/f_op_scene.cpp

@@ -7,15 +7,18 @@
 #include "f_pc/f_pc_manager.h"
 
 static int fopScn_Draw(scene_class* i_this) {
-    return fpcNd_DrawMethod((nodedraw_method_class*)i_this->submethod, i_this);
+    int ret = fpcNd_DrawMethod((nodedraw_method_class*)i_this->submethod, i_this);
+    return ret;
 }
 
 static int fopScn_Execute(scene_class* i_this) {
-    return fpcMtd_Execute(i_this->submethod, i_this);
+    int ret = fpcMtd_Execute(i_this->submethod, i_this);
+    return ret;
 }
 
 static int fopScn_IsDelete(void* i_this) {
-    return fpcMtd_IsDelete(static_cast<scene_class*>(i_this)->submethod, i_this);
+    int ret = fpcMtd_IsDelete(static_cast<scene_class*>(i_this)->submethod, i_this);
+    return ret;
 }
 
 static int fopScn_Delete(void* i_this) {

src/f_op/f_op_view.cpp

@@ -6,31 +6,36 @@
 #include "f_op/f_op_view.h"
 #include "f_pc/f_pc_manager.h"
 
-void fopVw_Draw(view_class* i_this) {
-    fpcLf_DrawMethod(i_this->sub_method, i_this);
+s32 fopVw_Draw(view_class* i_this) {
+    int ret = fpcLf_DrawMethod(i_this->sub_method, i_this);
+    return ret;
 }
 
-void fopVw_Execute(view_class* i_this) {
-    fpcMtd_Execute(&i_this->sub_method->base, i_this);
+s32 fopVw_Execute(view_class* i_this) {
+    int ret = fpcMtd_Execute(&i_this->sub_method->base, i_this);
+    return ret;
 }
 
 s32 fopVw_IsDelete(void* i_this) {
-    view_class* a_this = (view_class*)i_this;
-    return fpcMtd_IsDelete(&a_this->sub_method->base, a_this);
+    int ret = fpcMtd_IsDelete(&((view_class*)i_this)->sub_method->base, i_this);
+    return ret;
 }
 
 s32 fopVw_Delete(view_class* i_this) {
-    return fpcMtd_Delete(&i_this->sub_method->base, i_this);
+    int ret = fpcMtd_Delete(&i_this->sub_method->base, i_this);
+    return ret;
 }
 
 s32 fopVw_Create(void* i_this) {
     view_class* a_this = (view_class*)i_this;
+    int ret;
 
-    view_process_profile_definition* profile = (view_process_profile_definition*)fpcM_GetProfile(a_this);
+    view_process_profile_definition* profile = (view_process_profile_definition*)fpcM_GetProfile(i_this);
     a_this->sub_method = profile->sub_method;
     a_this->field_0xc4 = profile->unk_0x28;
 
-    return fpcMtd_Create(&a_this->sub_method->base, a_this);
+    ret = fpcMtd_Create(&a_this->sub_method->base, a_this);
+    return ret;
 }
 
 leafdraw_method_class g_fopVw_Method = {