Some game UI basics (#25)

* start with dLyt stuff, dLytFader_c

* Some game UI basics

* More progress

* Move and format files

* Proper outlining

* Fix build

* More cleanup

* Correct inlining behavior

* Fix some symbols

* Compiler downgrade required for some funcs.

* fixup vtable

* one line that was somehow missed

---------

Co-authored-by: elijah-thomas774 <elijahthomas774@gmail.com>

10 files changed, 851 insertions, 8 deletions

diff --git a/src/d/d_font_manager.cpp b/src/d/d_font_manager.cpp
index d258b186..c4588a9f 100644
--- a/src/d/d_font_manager.cpp
+++ b/src/d/d_font_manager.cpp
@@ -29,7 +29,7 @@ nw4r::ut::ResFont *dFontMng_c::getFont(u8 type) {
     return &l_dFontMng_obj[index].mFont;
 }
 
-const char *getFontName(u8 type) {
+const char *dFontMng_c::getFontName(u8 type) {
     return fonts[type];
 }
 
diff --git a/src/d/lyt/common_arrow.cpp b/src/d/lyt/common_arrow.cpp
new file mode 100644
index 00000000..486e3c65
--- /dev/null
+++ b/src/d/lyt/common_arrow.cpp
@@ -0,0 +1,235 @@
+#include <d/lyt/common_arrow.h>
+#include <toBeSorted/arc_managers/layout_arc_manager.h>
+
+STATE_DEFINE(dLytCommonArrow_c, None);
+STATE_DEFINE(dLytCommonArrow_c, In);
+STATE_DEFINE(dLytCommonArrow_c, Wait);
+STATE_DEFINE(dLytCommonArrow_c, Out);
+
+f32 arrow_fs[0x20];
+
+static const d2d::LytBrlanMapping brlanMap[] = {
+        {"commonArrow_00_in.brlan", "G_inOut_00"},
+        {"commonArrow_00_loop.brlan", "G_loop_00"},
+        {"commonArrow_00_type.brlan", "G_type_00"},
+        {"commonArrow_00_onOff.brlan", "G_arrowL_00"},
+        {"commonArrow_00_onOff.brlan", "G_arrowR_00"},
+        {"commonArrow_00_decide.brlan", "G_arrowL_00"},
+        {"commonArrow_00_decide.brlan", "G_arrowR_00"},
+        {"commonArrow_00_input.brlan", "G_input_00"},
+        {"commonArrow_00_out.brlan", "G_inOut_00"},
+};
+
+dLytCommonArrow_c::dLytCommonArrow_c() : mStateMgr(*this, sStateID::null) {}
+
+extern "C" d2d::dLytStructD *lbl_80575260;
+
+bool dLytCommonArrow_c::init() {
+    void *data = LayoutArcManager::sInstance->getLoadedData("CommonArrow");
+    mResAcc.attach(data, "");
+    mLytBase.build("commonArrow_00.brlyt", &mResAcc);
+    mLytBase.mPriority = 0x86;
+
+    for (int i = 0; i < 9; i++) {
+        field_0x440[i].init(brlanMap[i].mFile, &mResAcc, mLytBase.getLayout(), brlanMap[i].mName);
+    }
+    field_0x680.fn_80065E70(mLytBase.getLayout()->GetRootPane(), 1, 0, 0);
+    lbl_80575260->append(&field_0x680);
+    field_0x6A8 = mLytBase.findBounding("B_arrowL_00");
+    field_0x6AC = mLytBase.findBounding("B_arrowR_00");
+    mStateMgr.changeState(StateID_None);
+    setState(0);
+    return true;
+}
+
+bool dLytCommonArrow_c::fn_80168490() {
+    lbl_80575260->detach(&field_0x680);
+    mLytBase.unbindAnims();
+    for (int i = 0; i < 9; i++) {
+        field_0x440[i].fn_800AC860();
+    }
+    return true;
+}
+
+bool dLytCommonArrow_c::fn_80168500() {
+    mStateMgr.executeState();
+    if (!mStateMgr.getStateID()->isEqual(StateID_None)) {
+        field_0x440[1].mpFrameCtrl->play();
+        field_0x440[1].syncAnmFrame();
+    }
+    mLytBase.calc();
+    field_0x680.field_0x22 = 0;
+    field_0x680.fn_80065F70();
+    field_0x6BC = field_0x6B8;
+    return true;
+}
+
+bool dLytCommonArrow_c::addToDrawList() {
+    if (field_0x6CB == 1) {
+        mLytBase.addToDrawList();
+    }
+    return true;
+}
+
+void dLytCommonArrow_c::setState(s32 state) {
+    field_0x6B0 = state;
+    if (state == 0) {
+        mLytBase.mPriority = 0x86;
+    } else {
+        mLytBase.mPriority = 0x80;
+    }
+}
+
+void dLytCommonArrow_c::fn_80168640(f32 *arg) {
+    // TODO
+    mLytBase.getLayout()->GetRootPane()->SetTranslate(nw4r::math::VEC3(arg[0], arg[1], 0.0f));
+}
+
+bool dLytCommonArrow_c::fn_80168680() {
+    if (!mStateMgr.getStateID()->isEqual(StateID_None)) {
+        return false;
+    }
+    field_0x6C8 = 1;
+    return true;
+}
+
+bool dLytCommonArrow_c::fn_801686F0() {
+    if (!mStateMgr.getStateID()->isEqual(StateID_Wait)) {
+        return false;
+    }
+    field_0x6C9 = 1;
+    return true;
+}
+
+bool dLytCommonArrow_c::fn_80168760() {
+    if (field_0x6C0 == 2 && field_0x6B8 != 2) {
+        field_0x6C0 = field_0x6B8;
+        return true;
+    }
+    return false;
+}
+
+void dLytCommonArrow_c::fn_80168790(s32 idx, f32 frame) {
+    d2d::AnmGroup_c *s = &field_0x440[idx];
+    s->setFrame(frame);
+}
+
+void dLytCommonArrow_c::fn_80168800(s32 idx) {
+    field_0x440[idx].fn_800AC7D0();
+}
+
+void dLytCommonArrow_c::fn_80168810(d2d::AnmGroup_c *ctrl) {
+    if (ctrl->mpFrameCtrl->getFrame()) {
+        f32 newFrame = ctrl->mpFrameCtrl->getFrame() - 1.0f;
+        if (newFrame <= 0.0f) {
+            newFrame = 0.0f;
+        }
+        ctrl->mpFrameCtrl->setFrame(newFrame);
+        ctrl->syncAnmFrame();
+    }
+}
+
+void dLytCommonArrow_c::fn_80168880() {}
+
+void dLytCommonArrow_c::initializeState_None() {
+    mLytBase.unbindAnims();
+    field_0x6C8 = 0;
+    field_0x6C9 = 0;
+    field_0x6CA = 0;
+    field_0x6CB = 0;
+    field_0x6B4 = 2;
+    field_0x6B8 = 2;
+    field_0x6BC = 2;
+    field_0x6C0 = 2;
+    field_0x6C4 = 0;
+    fn_80168790(0, 0.0f);
+    field_0x6CC = 1;
+}
+void dLytCommonArrow_c::executeState_None() {
+    if (field_0x6C8 == 1) {
+        mStateMgr.changeState(StateID_In);
+    }
+}
+void dLytCommonArrow_c::finalizeState_None() {
+    field_0x6C8 = 0;
+    fn_80168790(1, 0.0f);
+}
+
+void dLytCommonArrow_c::initializeState_In() {
+    field_0x6C4 = 0;
+    field_0x6CB = 1;
+    f32 tmp = 0.0f;
+    if (field_0x6B0 == 1) {
+        tmp = 1.0f;
+    }
+    fn_80168790(2, tmp);
+    fn_80168790(3, 0.0f);
+    fn_80168790(4, 0.0f);
+    fn_80168790(7, 0.0f);
+}
+void dLytCommonArrow_c::executeState_In() {
+    switch (field_0x6C4) {
+    case 0:
+        d2d::AnmGroup_c *s = &field_0x440[0];
+        if (s->mpFrameCtrl->isEndReached() == 1) {
+            field_0x6C4 += 1;
+            field_0x6CA = 1;
+        } else {
+            s->mpFrameCtrl->play();
+            s->syncAnmFrame();
+        }
+        break;
+    case 1:
+        field_0x6CA = 0;
+        mStateMgr.changeState(StateID_Wait);
+        break;
+    }
+}
+void dLytCommonArrow_c::finalizeState_In() {
+    fn_80168800(0);
+}
+
+void dLytCommonArrow_c::initializeState_Wait() {
+    field_0x6C4 = 0;
+}
+void dLytCommonArrow_c::executeState_Wait() {
+    if (field_0x6C9 == 1) {
+        mStateMgr.changeState(StateID_Out);
+        return;
+    }
+
+    fn_80168880();
+    if (field_0x6B8 == 0) {
+        field_0x440[3].play();
+        fn_80168810(&field_0x440[4]);
+    } else if (field_0x6B8 == 1) {
+        field_0x440[4].play();
+        fn_80168810(&field_0x440[3]);
+    } else {
+        fn_80168810(&field_0x440[3]);
+        fn_80168810(&field_0x440[4]);
+    }
+}
+void dLytCommonArrow_c::finalizeState_Wait() {}
+
+void dLytCommonArrow_c::initializeState_Out() {
+    field_0x6C4 = 0;
+    fn_80168790(8, 0.0f);
+    field_0x6C9 = 0;
+}
+void dLytCommonArrow_c::executeState_Out() {
+    switch (field_0x6C4) {
+    case 0:
+        d2d::AnmGroup_c *s = &field_0x440[8];
+        if (s->mpFrameCtrl->isEndReached() == 1) {
+            field_0x6C4 = 1;
+            field_0x6CA = 1;
+        }
+        s->play();
+        break;
+    case 1:
+        mStateMgr.changeState(StateID_None);
+        break;
+    }
+}
+void dLytCommonArrow_c::finalizeState_Out() {}
diff --git a/src/d/lyt/d2d.cpp b/src/d/lyt/d2d.cpp
new file mode 100644
index 00000000..d72ea051
--- /dev/null
+++ b/src/d/lyt/d2d.cpp
@@ -0,0 +1,364 @@
+#include <d/d_font_manager.h>
+#include <d/lyt/d2d.h>
+#include <d/lyt/d_textbox.h>
+#include <d/lyt/d_window.h>
+#include <egg/gfx/eggScreen.h>
+#include <nw4r/lyt/lyt_bounding.h>
+#include <nw4r/lyt/lyt_group.h>
+#include <nw4r/lyt/lyt_picture.h>
+#include <nw4r/lyt/lyt_textBox.h>
+#include <nw4r/lyt/lyt_utils.h>
+#include <nw4r/lyt/lyt_window.h>
+
+using namespace nw4r::lyt;
+
+namespace d2d {
+
+void ResAccIf_c::detach() {
+    for (u8 i = 0; i < 5; i++) {
+        mAccessor.UnregistFont(&mFontRefLinks[i]);
+    }
+    m2d::ResAccIf_c::detach();
+}
+
+bool ResAccIf_c::attach(void *data, const char *name) {
+    nw4r::lyt::FontRefLink *link;
+    bool ok = m2d::ResAccIf_c::attach(data, name);
+    if (ok) {
+        for (u8 i = 0; i < 5; i++) {
+            link = &mFontRefLinks[i];
+            link->Set(dFontMng_c::getFontName(i), dFontMng_c::getFont(i));
+            mAccessor.RegistFont(link);
+        }
+    }
+
+    return ok;
+}
+
+// Copied from lyt, with some types replaced
+nw4r::lyt::Pane *Layout_c::BuildPaneObj(s32 kind, const void *dataPtr, const ResBlockSet &resBlockSet) {
+    // Oddly enough the breaks are required here to not inline the function???
+    // Had them as left over from editing and somehow when removing them it just broke Build.
+    // Probably some analysis depth as 3 break statements do it
+    switch (kind) {
+    case 'pan1': {
+        const res::Pane *pResPane = (const res::Pane *)dataPtr;
+        return NewObj<Pane>(pResPane);
+    } break;
+    case 'pic1': {
+        const res::Picture *pResPic = (const res::Picture *)dataPtr;
+        return NewObj<Picture>(pResPic, resBlockSet);
+    } break;
+    case 'txt1': {
+        const res::TextBox *pBlock = (const res::TextBox *)dataPtr;
+        return NewObj<dTextBox_c>(pBlock, resBlockSet);
+    } break;
+    case 'wnd1': {
+        const res::Window *pBlock = (const res::Window *)dataPtr;
+        return NewObj<dWindow_c>(pBlock, resBlockSet);
+    } break;
+    case 'bnd1': {
+        const res::Bounding *pResBounding = (const res::Bounding *)dataPtr;
+        return NewObj<Bounding>(pResBounding, resBlockSet);
+    } break;
+    default:
+        return nullptr;
+    }
+}
+
+// This is exactly copied from nw4r::lyt::Layout
+bool Layout_c::Build(const void *lytResBuf, ResourceAccessor *pResAcsr) {
+    const res::BinaryFileHeader *pFileHead = (const res::BinaryFileHeader *)(lytResBuf);
+    if (!detail::TestFileHeader(*pFileHead, 'RLYT')) {
+        return false;
+    }
+    if (!detail::TestFileVersion(*pFileHead)) {
+        return false;
+    }
+
+    ResBlockSet resBlockSet = {nullptr, nullptr, nullptr, pResAcsr};
+    Pane *pParentPane = nullptr;
+    Pane *pLastPane = nullptr;
+    bool bReadRootGroup = false;
+    int groupNestLevel = 0;
+
+    const void *dataPtr = ((u8 *)lytResBuf + pFileHead->headerSize);
+    for (int i = 0; i < pFileHead->dataBlocks; i++) {
+        const res::DataBlockHeader *pDataBlockHead = (const res::DataBlockHeader *)dataPtr;
+        switch (detail::GetSignatureInt(pDataBlockHead->kind)) {
+        case 'lyt1': // Main Layout
+        {
+            const res::Layout *pResLyt = ((const res::Layout *)dataPtr);
+            mLayoutSize = pResLyt->layoutSize;
+        } break;
+        case 'txl1': // Texture List
+            resBlockSet.pTextureList = (const res::TextureList *)dataPtr;
+            break;
+        case 'fnl1': // Font List
+            resBlockSet.pFontList = (const res::FontList *)dataPtr;
+            break;
+        case 'mat1': // Material
+            resBlockSet.pMaterialList = (const res::MaterialList *)dataPtr;
+            break;
+        case 'wnd1': // Window
+        case 'pan1': // Pane
+        case 'pic1': // Picture
+        case 'txt1': // Text Box
+        case 'bnd1': // Boundary Pane
+        {
+            Pane *pPane = BuildPaneObj(detail::GetSignatureInt(pDataBlockHead->kind), dataPtr, resBlockSet);
+            if (pPane) {
+                if (mpRootPane == nullptr) {
+                    mpRootPane = pPane;
+                }
+                if (pParentPane) {
+                    pParentPane->AppendChild(pPane);
+                }
+                pLastPane = pPane;
+            }
+        } break;
+        case 'usd1': // User Data
+            pLastPane->SetExtUserDataList((const res::ExtUserDataList *)dataPtr);
+            break;
+        case 'pas1': // PaneChildren Start
+            pParentPane = pLastPane;
+            break;
+        case 'pae1': // PaneChildren End
+            pLastPane = pParentPane;
+            pParentPane = pLastPane->GetParent();
+            break;
+        case 'grp1': // Group
+            if (!bReadRootGroup) {
+                bReadRootGroup = true;
+                mpGroupContainer = NewObj<GroupContainer>();
+            } else {
+                if (mpGroupContainer && groupNestLevel == 1) {
+                    Group *pGroup = NewObj<Group>((const res::Group *)dataPtr, mpRootPane);
+                    if (pGroup) {
+                        mpGroupContainer->AppendGroup(pGroup);
+                    }
+                }
+            }
+            break;
+        case 'grs1': // Group Children Start
+            groupNestLevel++;
+            break;
+        case 'gre1': // Group Children End
+            groupNestLevel--;
+            break;
+        default:
+            break;
+        }
+        dataPtr = ((u8 *)dataPtr + pDataBlockHead->size);
+    }
+    return true;
+}
+
+Multi_c::Multi_c() : Base_c(0x80), mLayout(), mDrawInfo(), mpResAcc(nullptr), mFlags(0) {
+    mDrawInfo.SetLocationAdjustScale(nw4r::math::VEC2((float)EGG::Screen::GetSizeXMax(EGG::Screen::TV_MODE_1) /
+                    (float)EGG::Screen::GetSizeXMax(EGG::Screen::TV_MODE_2),
+            1.0f));
+    mDrawInfo.SetLocationAdjust(true);
+}
+
+void Multi_c::animate() {
+    u32 arg = 0;
+    if ((mFlags & 1) != 0) {
+        arg = 1;
+    }
+    mLayout.Animate(arg);
+}
+
+void Multi_c::calc() {
+    calcBefore();
+    calcAfter();
+}
+
+void Multi_c::calcBefore() {
+    u32 arg = 0;
+    if ((mFlags & 1) != 0) {
+        arg = 1;
+    }
+    mLayout.Animate(arg);
+}
+
+void Multi_c::calcAfter() {
+    nw4r::ut::Rect rect = mLayout.GetLayoutRect();
+    mDrawInfo.SetViewRect(rect);
+    mDrawInfo.SetMultipleViewMtxOnDraw(true);
+    mLayout.CalculateMtx(mDrawInfo);
+}
+
+void Multi_c::draw() {}
+
+bool Multi_c::build(const char *name, m2d::ResAccIf_c *acc) {
+    if (mLayout.GetRootPane() != nullptr) {
+        return true;
+    }
+
+    if (acc == nullptr) {
+        acc = mpResAcc;
+        if (acc == nullptr) {
+            return false;
+        }
+    }
+
+    void *res = acc->getAccessor()->GetResource(0, name, nullptr);
+    if (res == nullptr) {
+        return false;
+    }
+
+    bool ok = mLayout.Build(res, acc->getAccessor());
+    if (ok) {
+        calc();
+    }
+    return ok;
+}
+
+nw4r::lyt::Pane *Multi_c::findPane(const char *name) const {
+    return mLayout.GetRootPane()->FindPaneByName(name, true);
+}
+
+nw4r::lyt::Picture *Multi_c::findPicture(const char *name) const {
+    nw4r::lyt::Pane *p = findPane(name);
+    if (p != nullptr) {
+        return nw4r::ut::DynamicCast<nw4r::lyt::Picture *>(p);
+    }
+    return nullptr;
+}
+
+nw4r::lyt::Bounding *Multi_c::findBounding(const char *name) const {
+    nw4r::lyt::Pane *p = findPane(name);
+    if (p != nullptr) {
+        return nw4r::ut::DynamicCast<nw4r::lyt::Bounding *>(p);
+    }
+    return nullptr;
+}
+
+void Multi_c::unbindAnims() {
+    mLayout.UnbindAllAnimation();
+}
+
+LytBase_c::LytBase_c() : mpMsbtInfo(nullptr) {}
+
+extern "C" void libms__LMS_CloseMessage(void *);
+LytBase_c::~LytBase_c() {
+    if (mpMsbtInfo != nullptr) {
+        libms__LMS_CloseMessage(mpMsbtInfo);
+    }
+}
+
+bool AnmGroup_c::init(const char *fileName, m2d::ResAccIf_c *resAcc, d2d::Layout_c *layout, const char *groupName) {
+    if (layout->GetGroupContainer() == nullptr) {
+        return false;
+    }
+
+    nw4r::lyt::Group *group = layout->GetGroupContainer()->FindGroupByName(groupName);
+    if (group == nullptr) {
+        return nullptr;
+    }
+    nw4r::lyt::AnimTransform *transform = layout->CreateAnimTransform();
+    return init(transform, fileName, resAcc, group);
+}
+
+bool AnmGroup_c::init(nw4r::lyt::AnimTransform *transform, const char *name, m2d::ResAccIf_c *acc,
+        nw4r::lyt::Group *group) {
+    if (transform == nullptr) {
+        return false;
+    }
+
+    if (group == nullptr) {
+        return false;
+    }
+
+    void *res = acc->getAccessor()->GetResource(0, name, nullptr);
+    if (res == nullptr) {
+        return false;
+    }
+
+    mAnmResource.Set(res);
+    u16 animNum = mAnmResource.CalcAnimationNum(group, mAnmResource.IsDescendingBind());
+    if (animNum != 0) {
+        transform->SetResource(mAnmResource.GetResourceBlock(), acc->getAccessor(), animNum);
+        mpGroup = group;
+        mpAnmTransform = transform;
+    }
+    return true;
+}
+
+bool AnmGroup_c::fn_800AC6D0(bool b) {
+    nw4r::lyt::AnimTransform *anmTransform = mpAnmTransform;
+    if (anmTransform == nullptr) {
+        return false;
+    }
+
+    if (mpGroup == nullptr) {
+        return false;
+    }
+
+    nw4r::lyt::BindAnimation(mpGroup, anmTransform, false, b);
+    mFlags |= 1;
+    if (b) {
+        mFlags = (mFlags & ~2);
+    } else {
+        mFlags |= 2;
+    }
+
+    u32 flags = 1;
+    if (mpAnmTransform->IsLoopData()) {
+        flags = 0;
+    }
+
+    mpFrameCtrl->set(anmTransform->GetFrameSize(), flags, 1.0f, -1.0f);
+    syncAnmFrame();
+    return true;
+}
+
+bool AnmGroup_c::fn_800AC7D0() {
+    nw4r::lyt::AnimTransform *anmTransform = mpAnmTransform;
+    if (anmTransform == nullptr) {
+        return false;
+    }
+
+    nw4r::lyt::Group *group = mpGroup;
+    if (group == nullptr) {
+        return false;
+    }
+
+    nw4r::lyt::UnbindAnimation(group, anmTransform, mAnmResource.IsDescendingBind());
+    mFlags = (mFlags & ~1);
+    return true;
+}
+
+bool AnmGroup_c::fn_800AC860() {
+    return true;
+}
+
+void AnmGroup_c::fn_800AC870(bool b) {
+    nw4r::lyt::Group *group = mpGroup;
+    nw4r::lyt::AnimTransform *anmTransform = mpAnmTransform;
+    nw4r::lyt::SetAnimationEnable(group, anmTransform, b, mAnmResource.IsDescendingBind());
+    if (b) {
+        mFlags |= 2;
+    } else {
+        mFlags = mFlags & ~2;
+    }
+}
+
+void AnmGroup_c::setAnmFrame(f32 arg) {
+    mpAnmTransform->SetFrame(arg);
+}
+
+void AnmGroup_c::syncAnmFrame() {
+    setAnmFrame(mpFrameCtrl->getFrame());
+}
+
+void AnmGroup_c::setForward() {
+    mpFrameCtrl->setForward();
+}
+
+void AnmGroup_c::setBackward() {
+    mpFrameCtrl->setBackward();
+}
+
+} // namespace d2d
diff --git a/src/d/lyt/d_lyt_fader.cpp b/src/d/lyt/d_lyt_fader.cpp
new file mode 100644
index 00000000..458b9315
--- /dev/null
+++ b/src/d/lyt/d_lyt_fader.cpp
@@ -0,0 +1,159 @@
+#include <d/lyt/d_lyt_fader.h>
+#include <toBeSorted/arc_managers/layout_arc_manager.h>
+
+static const d2d::LytBrlanMapping blanMap[] = {
+        {"wipe_01_wipeStart.brlan", "G_wipe_00"},
+        {"wipe_01_wipeOpen.brlan", "G_wipe_00"},
+        {"wipe_01_out.brlan", "G_out_00"},
+};
+
+dLytFader_c::dLytFader_c(const mColor &color, EStatus status) : mFaderBase_c(color, status), field_0x4DD(false) {}
+
+dLytFader_c::~dLytFader_c() {
+    0.0f; // float ordering
+
+    if (field_0x4DD == true) {
+        for (int i = 0; i < 3; i++) {
+            mLytStructAs[i].fn_800AC860();
+        }
+        mResAcc.detach();
+    }
+}
+
+void dLytFader_c::setStatus(EStatus status) {
+    if (status == FADED_OUT) {
+        mStatus = FADED_OUT;
+        mLytBase.unbindAnims();
+        d2d::AnmGroup_c *s = &mLytStructAs[0];
+        s->fn_800AC6D0(false);
+        s->setToEnd();
+        s->fn_800AC870(true);
+        s->play();
+        mLytBase.calc();
+        fn_80175BC0(2);
+        mLytBase.getLayout()->GetRootPane()->SetVisible(true);
+    } else if (status == FADED_IN) {
+        mStatus = FADED_IN;
+        mLytBase.unbindAnims();
+        d2d::AnmGroup_c *s = &mLytStructAs[0];
+        s->fn_800AC6D0(false);
+        s->setToStart();
+        s->fn_800AC870(true);
+        mLytBase.calc();
+        fn_80175BC0(2);
+        mLytBase.getLayout()->GetRootPane()->SetVisible(false);
+    }
+}
+
+bool dLytFader_c::calc() {
+    if (field_0x4DD == true) {
+        switch (field_0x4D4) {
+        case 0:
+            fn_801759B0();
+            break;
+        case 1:
+            fn_80175B10();
+            break;
+        default:
+            break;
+        }
+        return field_0x4D4 == 2;
+    } else {
+        return mFaderBase_c::calc();
+    }
+}
+
+extern "C" void fn_80016200();
+
+void dLytFader_c::draw() {
+    if (field_0x4DD) {
+        fn_80016200();
+        mLytBase.draw();
+    }
+}
+
+bool dLytFader_c::fadeIn() {
+    bool res = mFaderBase_c::fadeIn();
+    if (res) {
+        fn_80175A50();
+    }
+    return res;
+}
+
+bool dLytFader_c::fadeOut() {
+    bool res = mFaderBase_c::fadeOut();
+    if (res) {
+        fn_801758F0();
+    }
+    return res;
+}
+
+bool dLytFader_c::init() {
+    if (field_0x4DD == true) {
+        return true;
+    } else {
+        void *data = LayoutArcManager::sInstance->getLoadedData("System2D");
+        if (!data) {
+            return false;
+        }
+        mResAcc.attach(data, "");
+        mLytBase.setResAcc(&mResAcc);
+        mLytBase.build("wipe_01.brlyt", nullptr);
+
+        for (int i = 0; i < 3; i++) {
+            mLytStructAs[i].init(blanMap[i].mFile, &mResAcc, mLytBase.getLayout(), blanMap[i].mName);
+        }
+        field_0x4DD = true;
+        return true;
+    }
+}
+
+void dLytFader_c::fn_801758F0() {
+    fn_80175BC0(0);
+    mLytBase.unbindAnims();
+    d2d::AnmGroup_c *s = &mLytStructAs[0];
+    s->fn_800AC6D0(false);
+    s->mpFrameCtrl->setFrame(0.0f);
+    s->syncAnmFrame();
+    s->mpFrameCtrl->setRate(20.0f / (mFrame - 1));
+    s->fn_800AC870(true);
+    mLytBase.getLayout()->GetRootPane()->SetVisible(true);
+}
+
+void dLytFader_c::fn_801759B0() {
+    d2d::AnmGroup_c *s = &mLytStructAs[0];
+    if (s->mpFrameCtrl->isEndReached() == true) {
+        fn_80175BC0(2);
+        mStatus = FADED_OUT;
+    }
+    s->play();
+    mLytBase.calc();
+}
+
+void dLytFader_c::fn_80175A50() {
+    fn_80175BC0(1);
+    mLytBase.unbindAnims();
+    d2d::AnmGroup_c *s = &mLytStructAs[1];
+    s->fn_800AC6D0(false);
+    s->mpFrameCtrl->setFrame(0.0f);
+    s->syncAnmFrame();
+    s->mpFrameCtrl->setRate(20.0f / (mFrame - 1));
+    s->fn_800AC870(true);
+    mLytBase.getLayout()->GetRootPane()->SetVisible(true);
+}
+
+void dLytFader_c::fn_80175B10() {
+    d2d::AnmGroup_c *s = &mLytStructAs[1];
+    if (s->mpFrameCtrl->isEndReached() == true) {
+        fn_80175BC0(2);
+        mStatus = FADED_IN;
+        mLytBase.getLayout()->GetRootPane()->SetVisible(false);
+    }
+    s->play();
+    mLytBase.calc();
+}
+
+void dLytFader_c::fn_80175BC0(s32 arg) {
+    field_0x4D4 = arg;
+    field_0x4D8 = 0;
+}
diff --git a/src/d/lyt/d_window.cpp b/src/d/lyt/d_window.cpp
new file mode 100644
index 00000000..14c02a76
--- /dev/null
+++ b/src/d/lyt/d_window.cpp
@@ -0,0 +1,28 @@
+#include <d/lyt/d_textbox.h>
+#include <d/lyt/d_window.h>
+
+dWindow_c::dWindow_c(const nw4r::lyt::res::Window *pBlock, const nw4r::lyt::ResBlockSet &ResBlockSet)
+    : nw4r::lyt::Window(pBlock, ResBlockSet) {}
+
+void dWindow_c::UpdateSize(dTextBox_c *textBox, f32 f) {
+    if (textBox == nullptr) {
+        return;
+    }
+
+    u8 rem = mBasePosition % 3;
+    if (rem == 0) {
+        nw4r::math::VEC3 other = textBox->GetTranslate();
+        nw4r::math::VEC3 my = GetTranslate();
+        f = (other.x - my.x) * 2.0f;
+    } else if (rem == 2) {
+        nw4r::math::VEC3 other = textBox->GetTranslate();
+        nw4r::math::VEC3 my = GetTranslate();
+        f = (my.x - other.x) * 2.0f;
+    }
+
+    nw4r::lyt::Size size = GetSize();
+    f32 width = textBox->GetLineWidth(nullptr);
+    width += f;
+    size.width = width;
+    SetSize(size);
+}
diff --git a/src/d/lyt/pause_disp_00.cpp b/src/d/lyt/pause_disp_00.cpp
new file mode 100644
index 00000000..130a3a1f
--- /dev/null
+++ b/src/d/lyt/pause_disp_00.cpp
@@ -0,0 +1,57 @@
+#include <d/lyt/pause_disp_00.h>
+#include <nw4r/lyt/lyt_group.h>
+
+STATE_DEFINE(dLytPauseDisp00_c, None);
+STATE_DEFINE(dLytPauseDisp00_c, In);
+STATE_DEFINE(dLytPauseDisp00_c, Wait);
+STATE_DEFINE(dLytPauseDisp00_c, Select);
+STATE_DEFINE(dLytPauseDisp00_c, Ring);
+STATE_DEFINE(dLytPauseDisp00_c, GetDemo);
+STATE_DEFINE(dLytPauseDisp00_c, Out);
+
+extern d2d::LytBrlanMapping S_MAPPINGS[];
+extern "C" char lbl_804E8898[];
+
+extern const char *B_LIST[];
+
+dLytPauseDisp00_c::dLytPauseDisp00_c() : mStateMgr(*this, sStateID::null) {}
+
+extern "C" void fn_800AC3C0(nw4r::lyt::Group *, nw4r::ut::LinkList<d2d::dLytStructB, 0> *);
+extern "C" d2d::dLytStructD *lbl_80575260;
+
+void dLytPauseDisp00_c::init() {
+    mLytBase.build("pause_00.brlyt", nullptr);
+    mLytBase.mPriority = 0x86;
+
+    for (int i = 0; i < 0x7E; i++) {
+        field_0x00D0[i].init(S_MAPPINGS[i].mFile, nullptr, mLytBase.getLayout(), S_MAPPINGS[i].mName);
+    }
+
+    for (int i = 0; i < 0x18; i++) {
+        field_0x2050[i].init(nullptr, lbl_804E8898[i]);
+        mList.PushBack(&field_0x2050[i]);
+    }
+
+    if (mLytBase.getLayout()->GetGroupContainer() != nullptr) {
+        nw4r::lyt::Group *group = mLytBase.getLayout()->GetGroupContainer()->FindGroupByName("G_ref_00");
+        if (group != nullptr) {
+            fn_800AC3C0(group, &mList);
+        }
+    }
+
+    field_0xE29C.init(mLytBase.getLayout()->GetRootPane(), 1, 0, 0);
+    lbl_80575260->append(&field_0xE29C);
+    for (int i = 0; i < 0x25; i++) {
+        if (i != 0x1F && i != 0x20) {
+            nw4r::lyt::Bounding *b = mLytBase.findBounding(B_LIST[i]);
+            // TODO
+        }
+    }
+}
+
+void dLytPauseDisp00_c::displayElement(int i, float frame) {
+    d2d::AnmGroup_c *s = &field_0x00D0[i];
+    s->setFrame(frame);
+}
+
+dLytPauseDisp00_c::~dLytPauseDisp00_c() {}
diff --git a/src/egg/prim/eggAssert.cpp b/src/egg/prim/eggAssert.cpp
index bde46ca9..146012af 100644
--- a/src/egg/prim/eggAssert.cpp
+++ b/src/egg/prim/eggAssert.cpp
@@ -1,4 +1,3 @@
-#include <Runtime.PPCEABI.H/__va_arg.h>
 #include <egg/core/eggSystem.h>
 #include <egg/core/eggXfbManager.h>
 #include <egg/prim/eggAssert.h>
diff --git a/src/m/m2d.cpp b/src/m/m2d.cpp
index dab95700..65dec866 100644
--- a/src/m/m2d.cpp
+++ b/src/m/m2d.cpp
@@ -85,9 +85,10 @@ nw4r::lyt::ArcResourceAccessor *ResAccIf_c::getAccessor() {
 
 void ResAccIf_c::noop() {}
 
-void ResAccIf_c::attach(void *data, const char *name) {
-    mAccessor.Attach(data, name);
+bool ResAccIf_c::attach(void *data, const char *name) {
+    return mAccessor.Attach(data, name);
 }
+
 void ResAccIf_c::detach() {
     mAccessor.Detach();
 }
diff --git a/src/m/m_color_fader.cpp b/src/m/m_color_fader.cpp
index 66a03b35..e0713020 100644
--- a/src/m/m_color_fader.cpp
+++ b/src/m/m_color_fader.cpp
@@ -18,8 +18,8 @@ void mColorFader_c::setStatus(EStatus status) {
     }
 }
 
-u8 mColorFader_c::calc() {
-    u8 result = mFaderBase_c::calc();
+bool mColorFader_c::calc() {
+    bool result = mFaderBase_c::calc();
     u16 elapsed = mElapsed;
     u16 frame = mFrame;
     if (elapsed > mFrame) {
diff --git a/src/m/m_fader_base.cpp b/src/m/m_fader_base.cpp
index ae5c182b..598edc56 100644
--- a/src/m/m_fader_base.cpp
+++ b/src/m/m_fader_base.cpp
@@ -50,8 +50,8 @@ bool mFaderBase_c::fadeOut() {
     return canFadeOut;
 }
 
-u8 mFaderBase_c::calc() {
-    u8 result = 0;
+bool mFaderBase_c::calc() {
+    bool result = 0;
     if (mStatus == FADING_IN) {
         if (mElapsed++ > mFrame) {
             mStatus = FADED_IN;