Decompile gf_error_manager.cpp

config/RSBE01_02/splits.txt

@@ -55,6 +55,12 @@ sora/gf/gf_callback.cpp:
 sora/gf/gf_decomp.cpp:
 	.text       start:0x8001A48C end:0x8001A5C0
 
+sora/gf/gf_error_manager.cpp:
+	.text       start:0x8001AF08 end:0x8001B574
+	.sdata      start:0x8059C500 end:0x8059C508
+	.sbss       start:0x8059FFD0 end:0x8059FFD4
+	.sdata2     start:0x805A1480 end:0x805A14B0
+
 sora/gf/gf_error_check.cpp:
 	.text       start:0x8001B574 end:0x8001B784
 	.ctors      start:0x804064EC end:0x804064F0

configure.py

@@ -299,6 +299,7 @@ def MatchingFor(*versions):
             Object(Matching, "sora/gf/gf_camera_controller.cpp"),
             Object(Matching, "sora/gf/gf_callback.cpp"),
             Object(Matching, "sora/gf/gf_decomp.cpp"),
+            Object(Matching, "sora/gf/gf_error_manager.cpp"),
             Object(Matching, "sora/gf/gf_error_check.cpp"),
             Object(Matching, "sora/gf/gf_file_io_handle.cpp"),
             Object(Matching, "sora/gf/gf_file_io_request.cpp"),

src/sora/gf/gf_decomp.cpp

@@ -3,20 +3,20 @@
 #include <revolution/CX/CXCompression.h>
 #include <types.h>
 
-void gfDecomp::decomp(const CXStream* src, void* dest) {
+void gfDecomp::decomp(const CXStream* src, u32 streamLen) {
     if (!m_ready) {
         m_algo = static_cast<CompressionAlgo::Enum>(src->m_type << 4);
-        m_uncompSize = CXGetUncompressedSize(src);
-        unk8 = gfMemoryPool::alloc(m_heapAddr, m_uncompSize, 0x20);
+        m_decompSize = CXGetUncompressedSize(src);
+        m_decompData = gfMemoryPool::alloc(m_heapAddr, m_decompSize, 0x20);
         switch (m_algo) {
             case CompressionAlgo::RL:
-                CXInitUncompContextRL(&m_ctx, unk8);
+                CXInitUncompContextRL(&m_ctx, m_decompData);
                 break;
             case CompressionAlgo::LZ:
-                CXInitUncompContextLZ(&m_ctx, unk8);
+                CXInitUncompContextLZ(&m_ctx, m_decompData);
                 break;
             case CompressionAlgo::Huffman:
-                CXInitUncompContextHuffman(&m_ctx, unk8);
+                CXInitUncompContextHuffman(&m_ctx, m_decompData);
                 break;
             default:
                 break;
@@ -25,13 +25,13 @@ void gfDecomp::decomp(const CXStream* src, void* dest) {
     }
     switch (m_algo) {
         case CompressionAlgo::RL:
-            CXReadUncompRL(&m_ctx, src, dest);
+            CXReadUncompRL(&m_ctx, src, streamLen);
             break;
         case CompressionAlgo::LZ:
-            CXReadUncompLZ(&m_ctx, src, dest);
+            CXReadUncompLZ(&m_ctx, src, streamLen);
             break;
         case CompressionAlgo::Huffman:
-            CXReadUncompHuffman(&m_ctx, src, dest);
+            CXReadUncompHuffman(&m_ctx, src, streamLen);
             break;
         default:
             break;

src/sora/gf/gf_error_check.cpp

@@ -14,31 +14,31 @@ void gfErrorCheck::init() {
 
 void gfErrorCheck::check() {
     s32 status = DVDGetDriveStatus();
-    u32 r31;
+    u32 errCode;
     bool r30 = false;
     if (status == -1) {
         r30 = true;
-        r31 = 4;
+        errCode = 4;
     } else if (status == 4) {
         r30 = true;
-        r31 = 1;
+        errCode = 1;
     } else if (status == 11) {
         r30 = true;
-        r31 = 3;
+        errCode = 3;
     } else if (status == 6) {
         r30 = true;
-        r31 = 2;
+        errCode = 2;
     } else {
         const DVDDiskID* id1 = DVDGetCurrentDiskID();
         const DVDDiskID* id2 = gfFileIO::getDVDDiskId();
         if (true != DVDCompareDiskID(id1, id2)) {
             r30 = true;
-            r31 = 2;
+            errCode = 2;
         }
     }
 
     if (r30) {
-        gfErrorManager::getInstance()->notifyError(r31, 0);
+        gfErrorManager::getInstance()->notifyError(errCode, 0);
     } else {
         gfErrorManager::getInstance()->notifyErrorRecovery(false);
     }

src/sora/gf/gf_error_manager.cpp

@@ -0,0 +1,143 @@
+#include <gf/gf_decomp.h>
+#include <gf/gf_heap_manager.h>
+#include <gf/gf_error_manager.h>
+#include <gf/gf_pad_system.h>
+#include <gf/gf_shutdown_manager.h>
+#include <gm/gm_global.h>
+#include <ms/ms_message.h>
+#include <ms/ms_resfont.h>
+#include <nw4r/ut/ut_Color.h>
+#include <nw4r/ut/ut_ResFont.h>
+#include <revolution/GX.h>
+#include <revolution/CX/CXCompression.h>
+#include <snd/snd_system.h>
+#include <sr/sr_common.h>
+#include <types.h>
+
+// TODO: These belong to different files
+// .data start:0x80423980 end:0x8042ADD0
+extern CXStream g_LZEncodedAlertFont;
+extern nw4r::ut::ResFont g_AlertFont;
+extern const char* g_ErrorMsgTable[12];
+
+static gfErrorManager* g_gfErrorManager;
+
+gfErrorManager* gfErrorManager::getInstance() {
+    if (!g_gfErrorManager)
+        g_gfErrorManager = new (Heaps::SystemFW) gfErrorManager;
+    return g_gfErrorManager;
+}
+
+gfErrorManager* gfErrorManager::create() {
+    g_gfErrorManager = new (Heaps::SystemFW) gfErrorManager;
+    return g_gfErrorManager;
+}
+
+gfErrorManager::gfErrorManager() :
+    m_isFatal(false),
+    m_isSuspended(false),
+    m_unused(false),
+    m_isMoviePaused(false),
+    m_msgBgColor(nw4r::ut::Color::WHITE),
+    m_msgTextColor(nw4r::ut::Color::WHITE)
+{
+    m_errorCode = 0;
+    m_reasonCode = 0;
+    m_msgScreen = new (Heaps::SystemFW) Message(0x400, Heaps::SystemFW);
+
+    m_msgBgColor.Set(0xDE, 0xF3, 0xD7, 0xFF);
+    m_msgTextColor.Set(0x8B, 0xB6, 0x7D, 0xFF);
+
+    gfDecomp dec(gfHeapManager::getHeap(Heaps::GameGlobal));
+    dec.decomp(&g_LZEncodedAlertFont, 0x741E);
+    m_fontData = dec.m_decompData;
+    FontData::loadAlertFont(m_fontData);
+}
+
+void gfErrorManager::update() {
+    if (m_isSuspended) {
+        if (m_updateDone == 0) {
+            g_gfPadSystem->stopMotorAllForce();
+            g_gfHomeMenu->setBan(1, 4);
+        }
+        m_updateDone++;
+    }
+}
+
+void gfErrorManager::renderPre() {
+    Message* msg = m_msgScreen;
+    Message::drawBoxLine(m_msgBgColor, 0, 0, 0.0f, 0.0f, 640.0f, 480.0f, 0.0f);
+    msg->SetFont(g_AlertFont);
+    msg->changeMsgBuf(-1);
+    msg->clearMsgBuf();
+    msg->setFace(7);
+    msg->setFixedWidth(-1.0);
+    if (true == g_GameGlobal->getGlobalRecordMenuDatap()->m_isWidescreen)
+        msg->setScale(0.65f, 0.845f);
+    else
+        msg->setScale(0.65f);
+    msg->setCallProjection(0);
+    msg->setWindow(20.0f, 100.0f, 620.0f, 380.0f);
+    msg->setDrawFlag(0x101, 0x303);
+    msg->setColor(m_msgTextColor);
+    const char* msgText = g_ErrorMsgTable[m_errorCode];
+    if (0 == m_reasonCode)
+        msg->printf(msgText);
+    else {
+        msg->printf(msgText);
+        msg->printf("\n\n%d", m_reasonCode);
+    }
+}
+
+void gfErrorManager::render() {
+    Message* msg = m_msgScreen;
+    GXColor white;
+    white.b = 255;
+    white.a = 255;
+    white.g = 255;
+    white.r = 255;
+    GXSetFog(GX_FOG_NONE, white, 0.0f, 1000.0f, 1.0f, 1000.0f);
+    GXSetNumTevStages(1);
+    GXSetNumIndStages(0);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
+    GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0A0, false, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
+    GXSetNumTexGens(1);
+    GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 60, false, 125);
+    GXSetZCompLoc(true);
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetZMode(false, GX_ALWAYS, false);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0);
+    msg->printMsgBuf(FontData::FONT_ALERT);
+}
+
+void gfErrorManager::notifyError(u32 errorCode, u32 reasonCode) {
+    bool res;
+    notifyErrorHelper(res, errorCode);
+    if (res) {
+        m_reasonCode = reasonCode;
+        m_errorCode = errorCode;
+    }
+    if (!isRecoverable(m_errorCode)) {
+        m_isFatal = true;
+        g_gfShutdownManager.unkC = 0;
+    }
+}
+
+void gfErrorManager::notifyErrorRecovery(bool skip) {
+    if (m_isSuspended && !m_isFatal && !skip && isRecoverable(m_errorCode)) {
+        m_isSuspended = false;
+        m_updateDone = 0;
+        g_gfHomeMenu->setBan(0, 4);
+        if (mvMoviePlayer::getInstance()) {
+            if (!m_isMoviePaused)
+                mvMoviePlayer::getInstance()->resetPause();
+            m_isMoviePaused = false;
+        }
+        if (g_sndSystem)
+            g_sndSystem->specialResume();
+        if (g_gfHomeMenu)
+            g_gfHomeMenu->start();
+    }
+}

src/sora/gf/gf_shutdown_manager.cpp

@@ -36,9 +36,7 @@ void gfShutdownManager::enterReturnToWiiMenuProcess() {
 void gfShutdownManager::update() {
     if (m_reset || m_powerOff || m_returnToWiiMenu) {
         if (unkC && unkD) {
-            if (!unk0_b3 &&
-                (gfErrorManager::getInstance()->unk0_b6 != true ||
-                gfErrorManager::getInstance()->unk0_b7)) {
+            if (!unk0_b3 && (gfErrorManager::getInstance()->m_isSuspended != true || gfErrorManager::getInstance()->m_isFatal)) {
                 unk8.add(gmSysSave::create(Heaps::GlobalMode));
                 unk0_b3 = true;
             }