More work

Author: kiwi515

lib/libkiwi/core/kiwiSceneCreator.cpp

@@ -79,6 +79,8 @@ TMap<s32, SceneCreator::Info> SceneCreator::sUserScenes;
 
 //! Root debug menu scene ID
 s32 SceneCreator::sDebugRootID = -1;
+//! Whether to boot into the root debug menu
+bool SceneCreator::sDebugRootBootUp = false;
 //! Root debug menu button combination (held)
 u16 SceneCreator::sDebugRootButtons = 0xFFFF;
 
@@ -132,16 +134,19 @@ void SceneCreator::RegistScene(const Info& rInfo) {
 /**
  * @brief Registers root debug menu information
  * @details The debug root scene is entered when transitioning to the main
- * menu while the specified button mask is held.
+ * menu while the specified button mask is held, or always on first boot
+ * if the bootUp flag is set.
  *
  * @param id Debug root scene ID (-1 to disable)
- * @param buttons Buttons that must be held to visit the debug menu
- * (defaults to B+Minus+1+2)
+ * @param bootUp Whether to boot into the debug root scene
+ * @param buttons Buttons that must be held to visit the debug root scene
+ * (defaults to B+MINUS)
  */
-void SceneCreator::RegistDebugRoot(s32 id, u16 buttons) {
+void SceneCreator::RegistDebugRoot(s32 id, bool bootUp, u16 buttons) {
     K_ASSERT_EX(id >= 0 || id == -1, "Invalid scene ID");
 
     sDebugRootID = id;
+    sDebugRootBootUp = bootUp;
     sDebugRootButtons = buttons;
 }
 
@@ -194,13 +199,18 @@ bool SceneCreator::ChangeSceneAfterFade(s32 id, bool reload) {
     }
 
     // Visit debug root instead of menu if buttons are held
-    if (id == GetMenuScene() && mLastSceneID != sDebugRootID) {
+    if (id == GetMenuScene() && current != sDebugRootID) {
         for (int i = 0; i < EPlayer_Max; i++) {
             const WiiCtrl& rCtrl =
                 CtrlMgr::GetInstance().GetWiiCtrl(static_cast<EPlayer>(i));
 
-            if (sDebugRootButtons == 0 ||
-                rCtrl.IsConnected() && rCtrl.IsHold(sDebugRootButtons)) {
+            bool visit = sDebugRootBootUp;   // Visit on boot
+            visit |= sDebugRootButtons == 0; // Always visit
+            visit |= rCtrl.IsConnected() &&
+                     rCtrl.IsHold(sDebugRootButtons); // Button combo held
+
+            if (visit) {
+                sDebugRootBootUp = false;
                 id = sDebugRootID;
                 break;
             }
@@ -244,14 +254,19 @@ bool SceneCreator::ChangeSceneAfterFade(s32 id, const nw4r::ut::Color* pColor) {
         id = current;
     }
 
-    // Visit debug root instead of menu if buttons are held
-    if (id == GetMenuScene() && mLastSceneID != sDebugRootID) {
+    // Visit debug root instead of menu if on boot, or if buttons are held
+    if (id == GetMenuScene() && current != sDebugRootID) {
         for (int i = 0; i < EPlayer_Max; i++) {
             const WiiCtrl& rCtrl =
                 CtrlMgr::GetInstance().GetWiiCtrl(static_cast<EPlayer>(i));
 
-            if (sDebugRootButtons == 0 ||
-                rCtrl.IsConnected() && rCtrl.IsHold(sDebugRootButtons)) {
+            bool visit = sDebugRootBootUp;   // Visit on boot
+            visit |= sDebugRootButtons == 0; // Always visit
+            visit |= rCtrl.IsConnected() &&
+                     rCtrl.IsHold(sDebugRootButtons); // Button combo held
+
+            if (visit) {
+                sDebugRootBootUp = false;
                 id = sDebugRootID;
                 break;
             }

lib/libkiwi/core/kiwiSceneCreator.h

@@ -192,15 +192,16 @@ class SceneCreator : public ExtSingletonPtr<RPSysSceneCreator, SceneCreator> {
     /**
      * @brief Registers root debug menu information
      * @details The debug root scene is entered when transitioning to the main
-     * menu while the specified button mask is held.
+     * menu while the specified button mask is held, or always on first boot
+     * if the bootUp flag is set.
      *
      * @param id Debug root scene ID (-1 to disable)
-     * @param buttons Buttons that must be held to visit the debug menu
-     * (defaults to B+MINUS+2)
+     * @param bootUp Whether to boot into the debug root scene
+     * @param buttons Buttons that must be held to visit the debug root scene
+     * (defaults to B+MINUS)
      */
-    static void RegistDebugRoot(s32 id,
-                                u16 buttons = (EButton_B | EButton_Minus |
-                                               EButton_2));
+    static void RegistDebugRoot(s32 id, bool bootUp = true,
+                                u16 buttons = EButton_B | EButton_Minus);
 
     /**
      * @brief Gets the scene ID of the main menu scene
@@ -347,6 +348,8 @@ class SceneCreator : public ExtSingletonPtr<RPSysSceneCreator, SceneCreator> {
 
     //! Root debug menu scene ID
     static s32 sDebugRootID;
+    //! Whether to boot into the root debug menu
+    static bool sDebugRootBootUp;
     //! Root debug menu button combination (held)
     static u16 sDebugRootButtons;
 };

lib/libkiwi/debug/kiwiDebugMenu.cpp

@@ -9,22 +9,22 @@ namespace kiwi {
  ******************************************************************************/
 
 /**
- * @brief Constructor
+ * @brief Opens a new menu page
  *
- * @param pRootPage Menu root page
+ * @param rPage Menu page
  */
-DebugMenu::DebugMenu(DebugPage* pRootPage) {
-    K_ASSERT(pRootPage != nullptr);
-    mPageStack.Push(pRootPage);
+void DebugMenu::OpenPage(DebugPage& rPage) {
+    rPage.SetParent(*this);
+    mPageStack.Push(&rPage);
 }
 
 /**
  * @brief Updates the menu state
  * @return Result of actions
  */
-DebugMenu::EResult DebugMenu::Calculate() {
+EDebugMenuResult DebugMenu::Calculate() {
     if (mPageStack.Empty()) {
-        return EResult_None;
+        return EDebugMenuResult_None;
     }
 
     return mPageStack.Top().Calculate();
@@ -50,26 +50,24 @@ void DebugMenu::UserDraw() {
 /**
  * @brief Appends a new option to the page
  *
- * @param pOption Debug option
+ * @param rOption Debug option
  * @return Success
  */
-bool DebugPage::AddOption(DebugOptionBase* pOption) {
-    K_ASSERT(pOption != nullptr);
-
+bool DebugPage::AddOption(DebugOptionBase& rOption) {
     if (mOptions.Size() >= mMaxOptions) {
-        K_LOG_EX("Can't add option: %s\n", pOption->GetName().CStr());
+        K_LOG_EX("Can't add option: %s\n", rOption.GetName().CStr());
         return false;
     }
 
-    mOptions.PushBack(pOption);
+    mOptions.PushBack(&rOption);
     return true;
 }
 
 /**
  * @brief Updates the menu state
  * @return Result of actions
  */
-DebugMenu::EResult DebugPage::Calculate() {
+EDebugMenuResult DebugPage::Calculate() {
     for (int i = 0; i < EPlayer_Max; i++) {
         const WiiCtrl& rCtrl =
             CtrlMgr::GetInstance().GetWiiCtrl(static_cast<EPlayer>(i));
@@ -81,10 +79,11 @@ DebugMenu::EResult DebugPage::Calculate() {
         // Highlight option with Up/Down
         if (rCtrl.IsTrig(EButton_Up)) {
             mCursor = mCursor == 0 ? mOptions.Size() - 1 : mCursor - 1;
-            return DebugMenu::EResult_Change;
+            return EDebugMenuResult_Cursor;
+
         } else if (rCtrl.IsTrig(EButton_Down)) {
             mCursor = mCursor == mOptions.Size() - 1 ? 0 : mCursor + 1;
-            return DebugMenu::EResult_Change;
+            return EDebugMenuResult_Cursor;
         }
 
         K_ASSERT(0 <= mCursor && mCursor < mOptions.Size());
@@ -95,52 +94,53 @@ DebugMenu::EResult DebugPage::Calculate() {
         // Change option with Left/Right
         if (rCtrl.IsTrig(EButton_Right)) {
             pOption->Increment();
-            return DebugMenu::EResult_Change;
+            return EDebugMenuResult_Change;
+
         } else if (rCtrl.IsTrig(EButton_Left)) {
             pOption->Decrement();
-            return DebugMenu::EResult_Change;
+            return EDebugMenuResult_Change;
         }
 
         // Select option with A
         if (rCtrl.IsTrig(EButton_A)) {
             pOption->Select();
-            return DebugMenu::EResult_Change;
+            return EDebugMenuResult_Select;
         }
 
         // Close page with B
         if (rCtrl.IsTrig(EButton_B)) {
-            return DebugMenu::EResult_Close;
+            return EDebugMenuResult_Close;
         }
     }
 
-    return DebugMenu::EResult_None;
+    return EDebugMenuResult_None;
 }
 
 /**
  * @brief User-level render pass
  */
 void DebugPage::UserDraw() {
-    f32 x = 0.25f;
+    f32 x = 0.15f;
     f32 y = 0.20f;
+
+    static const f32 cursor = 0.015f;
+    static const f32 option = 0.25f;
     static const f32 row = 0.05f;
 
     for (u32 i = 0; i < mOptions.Size(); i++) {
         Text(mOptions[i]->GetName())
             .SetStrokeType(ETextStroke_Outline)
-            .SetPosition(x + 0.00, y + 0.00)
-            .SetScale(0.8);
+            .SetPosition(x, y);
 
         Text(mOptions[i]->GetValueText())
             .SetStrokeType(ETextStroke_Outline)
-            .SetPosition(x + 0.15, y + 0.00)
-            .SetScale(0.8);
+            .SetPosition(x + option, y);
 
         // Show cursor at selected option
         if (i == mCursor) {
             Text("*")
                 .SetStrokeType(ETextStroke_Outline)
-                .SetPosition(x - 0.015, y)
-                .SetScale(0.8);
+                .SetPosition(x - cursor, y);
         }
 
         y += row;

lib/libkiwi/debug/kiwiDebugMenu.h

@@ -13,39 +13,49 @@ namespace kiwi {
 class DebugOptionBase;
 class DebugPage;
 
+/**
+ * @brief Debug menu action result
+ */
+enum EDebugMenuResult {
+    EDebugMenuResult_None,    //!< Nothing happened
+    EDebugMenuResult_Invalid, //!< State failed to change
+    EDebugMenuResult_Cursor,  //!< Cursor changed
+    EDebugMenuResult_Change,  //!< State changed
+    EDebugMenuResult_Select,  //!< Button selected
+    EDebugMenuResult_Close,   //!< Request to close page/menu
+};
+
 /**
  * @brief Debug menu
  */
 class DebugMenu : public IRPGrpDrawObject {
-public:
-    /**
-     * @brief Option action result
-     */
-    enum EResult {
-        EResult_None,    //!< Nothing happened
-        EResult_Invalid, //!< State failed to change
-        EResult_Change,  //!< State changed
-        EResult_Close,   //!< Request to close menu
-    };
-
 public:
     /**
      * @brief Constructor
      *
-     * @param pRootPage Menu root page
+     * @param rRootPage Menu root page
      */
-    DebugMenu(DebugPage* pRootPage);
+    DebugMenu(DebugPage& rRootPage) {
+        OpenPage(rRootPage);
+    }
 
     /**
      * @brief Destructor
      */
     virtual ~DebugMenu() {}
 
+    /**
+     * @brief Opens a new menu page
+     *
+     * @param rPage Menu page
+     */
+    void OpenPage(DebugPage& rPage);
+
     /**
      * @brief Updates the menu state
      * @return Result of actions
      */
-    virtual EResult Calculate();
+    virtual EDebugMenuResult Calculate();
 
     /**
      * @brief User-level render pass
@@ -74,26 +84,45 @@ class DebugPage {
     DebugPage(u32 maxOptions = DEFAULT_MAX_OPTIONS)
         : mCursor(0), mMaxOptions(maxOptions) {}
 
+    /**
+     * @brief Gets the page's parent menu
+     */
+    DebugMenu& GetParent() const {
+        K_ASSERT(mpParent != nullptr);
+        return *mpParent;
+    }
+    /**
+     * @brief Sets the page's parent menu
+     *
+     * @param rMenu Parent menu
+     */
+    void SetParent(DebugMenu& rMenu) {
+        mpParent = &rMenu;
+    }
+
     /**
      * @brief Appends a new option to the page
      *
-     * @param pOption Debug option
+     * @param rOption Debug option
      * @return Success
      */
-    bool AddOption(DebugOptionBase* pOption);
+    bool AddOption(DebugOptionBase& rOption);
 
     /**
      * @brief Updates the menu state
      * @return Result of actions
      */
-    virtual DebugMenu::EResult Calculate();
+    virtual EDebugMenuResult Calculate();
 
     /**
      * @brief User-level render pass
      */
     virtual void UserDraw();
 
 protected:
+    //! Parent menu
+    DebugMenu* mpParent;
+
     //! Cursor position
     u32 mCursor;
     //! Maximum number of options