Some misc graphics stuff

src/REL/d/a/obj/d_a_obj_treasure_island.cpp

@@ -45,7 +45,7 @@ bool dAcOtreasureIsland_c::createHeap() {
         }
 
         mdl = mResFile.GetResMdl("IslTreCWater01");
-        UnkWithWater::linkMdl(mdl, &waterStuff);
+        d3d::UnkWithWater::linkMdl(mdl, &waterStuff);
         TRY_CREATE(mWater01.create(mdl, &heap_allocator, 0x324));
 
         if (dStage_c::getMA0IndirectSrt(&anmSrt, mdl)) {

src/d/d_room.cpp

@@ -38,8 +38,8 @@
 #include "nw4r/math/math_types.h"
 #include "sized_string.h"
 #include "toBeSorted/arc_managers/current_stage_arc_manager.h"
+#include "toBeSorted/d_d3d.h"
 #include "toBeSorted/time_area_mgr.h"
-#include "toBeSorted/unk_with_water.h"
 
 SPECIAL_BASE_PROFILE(ROOM, dRoom_c, fProfile::ROOM, 0x9, 96);
 
@@ -473,7 +473,7 @@ void dRoom_c::mdl_c::doSomethingWithVis(bool arg) {
     }
 }
 
-bool dRoom_c::model_c::create(nw4r::g3d::ResFile resFile, mAllocator_c &alloc, s32 idx, UnkWithWater *waterThing) {
+bool dRoom_c::model_c::create(nw4r::g3d::ResFile resFile, mAllocator_c &alloc, s32 idx, d3d::UnkWithWater *waterThing) {
     SizedString<16> mdlName;
     mdlName.sprintf("model%d", idx >> 1);
     if ((idx & 1) != 0) {
@@ -485,7 +485,7 @@ bool dRoom_c::model_c::create(nw4r::g3d::ResFile resFile, mAllocator_c &alloc, s
         return true;
     }
 
-    bool linkResult = UnkWithWater::linkMdl(mdl, waterThing);
+    bool linkResult = d3d::UnkWithWater::linkMdl(mdl, waterThing);
     if (!mMdl.create(mdl, alloc)) {
         return false;
     }
@@ -601,11 +601,9 @@ void dRoom_c::model_c::draw(int roomid) {
     mMdl.entry();
 }
 
-extern "C" void fn_80017B10(nw4r::g3d::ResMdl &mdl, bool, bool);
-
 void dRoom_c::model_c::configureSomething(int roomid, mdl_c *mdl) {
     nw4r::g3d::ResMdl resMdl = mdl->getResMdl();
-    fn_80017B10(resMdl, true, false);
+    d3d::setRoomTevColors(resMdl, true, false);
 }
 
 const DrawPriorityConfig cfg[] = {

src/m/m3d/m_anmmdl.cpp

@@ -14,8 +14,8 @@ void mdlAnmChr::setFrame(f32 f) {
     mAnm.setFrameOnly(f);
 }
 
-void mdlAnmChr::setAnm(const char *name, playMode_e mode) {
-    setAnm(name, mode, 0.0f);
+bool mdlAnmChr::setAnm(const char *name, playMode_e mode) {
+    return setAnm(name, mode, 0.0f);
 }
 
 void mdlAnmChr::setRate(f32 rate) {
@@ -75,13 +75,13 @@ bool mdlAnmChr::create(
     return create(resFile, resFile, mdlName, anmName, nullptr, alloc, bufferOption, nView, pSize);
 }
 
-void mdlAnmChr::setAnm(const char *name, playMode_e mode, f32 blend) {
+bool mdlAnmChr::setAnm(const char *name, playMode_e mode, f32 blend) {
     nw4r::g3d::ResAnmChr anm = mAnmFile.GetResAnmChr(name);
     if (!anm.IsValid()) {
         anm = mMdlFile.GetResAnmChr(name);
     }
     mAnm.setAnm(mMdl, anm, mode);
-    mMdl.setAnm(mAnm, blend);
+    return mMdl.setAnm(mAnm, blend);
 }
 
 } // namespace m3d

src/m/m3d/m_bmdl.cpp

@@ -49,17 +49,17 @@ bool bmdl_c::getNodeWorldMtxMultVec(u32 p1, nw4r::math::VEC3 &in, nw4r::math::VE
     }
 }
 
-void bmdl_c::setAnm(banm_c &anm) {
+bool bmdl_c::setAnm(banm_c &anm) {
     nw4r::g3d::ScnMdlSimple *mdl;
     if (anm.getType() == nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_SHP) {
         mdl = nw4r::g3d::G3dObj::DynamicCast<nw4r::g3d::ScnMdl>(mpScnLeaf);
-        mdl->SetAnmObj(anm.getAnimObj(), nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_NOT_SPECIFIED);
+        return mdl->SetAnmObj(anm.getAnimObj(), nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_NOT_SPECIFIED);
     } else {
         mdl = nw4r::g3d::G3dObj::DynamicCast<nw4r::g3d::ScnMdlSimple>(mpScnLeaf);
         if (anm.getType() == nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_CHR) {
             mpCurrentAnm = &anm;
         }
-        mdl->SetAnmObj(anm.getAnimObj(), nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_NOT_SPECIFIED);
+        return mdl->SetAnmObj(anm.getAnimObj(), nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_NOT_SPECIFIED);
     }
 }
 

src/m/m3d/m_mdl.cpp

@@ -217,8 +217,8 @@ void mdl_c::remove() {
     bmdl_c::remove();
 }
 
-void mdl_c::setAnm(m3d::banm_c &anm) {
-    setAnm(anm, 0.0f);
+bool mdl_c::setAnm(m3d::banm_c &anm) {
+    return setAnm(anm, 0.0f);
 }
 
 void mdl_c::play() {
@@ -226,11 +226,11 @@ void mdl_c::play() {
     mpCallback->calcBlend();
 }
 
-void mdl_c::setAnm(m3d::banm_c &anm, f32 f) {
+bool mdl_c::setAnm(m3d::banm_c &anm, f32 f) {
     if (anm.getType() == nw4r::g3d::ScnMdlSimple::ANMOBJTYPE_CHR) {
         mpCallback->setBlendFrame(f);
     }
-    bmdl_c::setAnm(anm);
+    return bmdl_c::setAnm(anm);
 }
 
 void mdl_c::setCallback(callback_c *cb) {

src/toBeSorted/blur_and_palette_manager.cpp

@@ -182,8 +182,8 @@ BlurAndPaletteManager::BlurAndPaletteManager() {
     field_0x5CE4.MA01_tevReg1 = mColor(0xff, 0xff, 0xff, 0xff);
     field_0x5CE4.MA01_kColor2 = mColor(0xff, 0xff, 0xff, 0xff);
     field_0x5CE4.MA02_tevReg1 = mColor(0xff, 0xff, 0xff, 0xff);
-    field_0x5CE4.MA02_kcolor2 = mColor(0xff, 0xff, 0xff, 0xff);
-    field_0x5CE4.MA03_kcolor3 = mColor(0xff, 0xff, 0xff, 0xff);
+    field_0x5CE4.MA02_kColor2 = mColor(0xff, 0xff, 0xff, 0xff);
+    field_0x5CE4.MA03_kColor3 = mColor(0xff, 0xff, 0xff, 0xff);
 
     field_0x5D04.field_0x00 = field_0x5CE4;
     field_0x5D04.field_0x20 = field_0x5CE4;

src/toBeSorted/d_d3d.cpp

@@ -0,0 +1,408 @@
+#include "toBeSorted/d_d3d.h"
+
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/d_sc_game.h"
+#include "d/t/d_t_siren.h"
+#include "egg/gfx/eggCpuTexture.h"
+#include "egg/gfx/eggScreen.h"
+#include "m/m3d/m_anmmdl.h"
+#include "m/m3d/m_proc.h"
+#include "m/m3d/m_scnleaf.h"
+#include "m/m_color.h"
+#include "nw4r/g3d/g3d_scnobj.h"
+#include "nw4r/g3d/res/g3d_resanmchr.h"
+#include "nw4r/g3d/res/g3d_resfile.h"
+#include "nw4r/g3d/res/g3d_resmat.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/g3d/res/g3d_restev.h"
+#include "rvl/GX/GXTexture.h"
+#include "rvl/GX/GXTypes.h"
+#include "rvl/VI/vi.h"
+#include "sized_string.h"
+#include "toBeSorted/blur_and_palette_manager.h"
+
+namespace d3d {
+
+static EGG::Screen sSomeScreen;
+static SomeList sSomeList;
+
+AnmMdlWrapper::AnmMdlWrapper() : mpSoundSource(nullptr), mpSoundData(nullptr) {}
+
+AnmMdlWrapper::~AnmMdlWrapper() {
+    if (mpSoundSource != nullptr) {
+        if (mpSoundSource->shutdown()) {
+            do {
+                VIWaitForRetrace();
+            } while (mpSoundSource->shutdown());
+        }
+    }
+}
+
+bool AnmMdlWrapper::create(
+    dAcBase_c &ac, void *mdlFile, void *anmFile, const char *mdlName, const char *anmName, u32 bufferOption
+) {
+    if (!m3d::mdlAnmChr::create(mdlFile, anmFile, mdlName, anmName, &ac.heap_allocator, bufferOption, 1, nullptr)) {
+        return false;
+    }
+    mpSoundSource = ac.getSoundSource();
+    return true;
+}
+
+bool AnmMdlWrapper::create2(
+    dAcBase_c &ac, void *mdlFile, void *anmFile, const char *mdlName, const char *anmName, u32 bufferOption
+) {
+    return create(ac, mdlFile, anmFile, mdlName, anmName, bufferOption);
+}
+
+bool AnmMdlWrapper::create(
+    dAcBase_c &ac, void *mdlFile, void *anmFile, const char *mdlName, const char *anmName,
+    m3d::mdl_c::mdlCallback_c *callback, u32 bufferOption
+) {
+    if (!m3d::mdlAnmChr::create(
+            mdlFile, anmFile, mdlName, anmName, callback, &ac.heap_allocator, bufferOption, 1, nullptr
+        )) {
+        return false;
+    }
+    mpSoundSource = ac.getSoundSource();
+    return true;
+}
+
+bool AnmMdlWrapper::create2(
+    dAcBase_c &ac, void *mdlFile, void *anmFile, const char *mdlName, const char *anmName,
+    m3d::mdl_c::mdlCallback_c *callback, u32 bufferOption
+) {
+    return create(ac, mdlFile, anmFile, mdlName, anmName, callback, bufferOption);
+}
+
+bool AnmMdlWrapper::create(dAcBase_c &ac, void *resFile, const char *mdlName, const char *anmName, u32 bufferOption) {
+    return create(ac, resFile, resFile, mdlName, anmName, bufferOption);
+}
+
+bool AnmMdlWrapper::create2(dAcBase_c &ac, void *resFile, const char *mdlName, const char *anmName, u32 bufferOption) {
+    return create(ac, resFile, mdlName, anmName, bufferOption);
+}
+
+bool AnmMdlWrapper::create(
+    dAcBase_c &ac, void *mdlFile, const char *mdlName, const char *anmName, m3d::mdl_c::mdlCallback_c *callback,
+    u32 bufferOption
+) {
+    return create(ac, mdlFile, mdlFile, mdlName, anmName, callback, bufferOption);
+}
+
+bool AnmMdlWrapper::create2(
+    dAcBase_c &ac, void *mdlFile, const char *mdlName, const char *anmName, m3d::mdl_c::mdlCallback_c *callback,
+    u32 bufferOption
+) {
+    return create(ac, mdlFile, mdlName, anmName, callback, bufferOption);
+}
+
+void AnmMdlWrapper::play() {
+    m3d::mdlAnmChr::play();
+    syncAnmFrame();
+}
+
+void AnmMdlWrapper::setFrame(f32 frame) {
+    m3d::mdlAnmChr::setFrame(frame);
+    syncAnmFrame();
+}
+
+bool AnmMdlWrapper::setAnm(const char *name, m3d::playMode_e mode, f32 frame) {
+    if (!m3d::mdlAnmChr::setAnm(name, mode, frame)) {
+        return false;
+    }
+    return loadSounds(name);
+}
+
+void AnmMdlWrapper::setRate(f32 rate) {
+    m3d::mdlAnmChr::setRate(rate);
+    setSoundRate(rate);
+}
+
+void AnmMdlWrapper::setSoundSource(SoundSource *pSource) {
+    mpSoundSource = pSource;
+}
+
+bool AnmMdlWrapper::loadSounds(const char *name) {
+    if (mpSoundSource == nullptr || !mpSoundSource->isReadyMaybe()) {
+        return true;
+    }
+
+    SizedString<64> resPath;
+    resPath.sprintf("%s.brasd", name);
+    mpSoundData = mAnmFile.GetExternalData(resPath);
+    if (mpSoundData == nullptr) {
+        mpSoundData = mMdlFile.GetExternalData(resPath);
+    }
+    mpSoundSource->load(mpSoundData, name);
+
+    return true;
+}
+
+void AnmMdlWrapper::setSoundRate(f32 rate) {
+    if (mpSoundSource != nullptr) {
+        mpSoundSource->setRate(rate);
+    }
+}
+
+void AnmMdlWrapper::syncAnmFrame() {
+    if (mpSoundSource != nullptr) {
+        mpSoundSource->setFrame(getAnm().getFrame());
+    }
+}
+
+bool AnmMdlWrapper2::createExt(
+    dAcBase_c &ac, void *mdlFile, void *anmFile, void *ext1, void *ext2, const char *mdlName, const char *anmName,
+    m3d::mdl_c::mdlCallback_c *callback, u32 bufferOption
+) {
+    if (!create2(ac, mdlFile, anmFile, mdlName, anmName, callback, bufferOption)) {
+        return false;
+    }
+
+    if (ext1 != nullptr) {
+        mExt1 = nw4r::g3d::ResFile(ext1);
+        mHasExt1 = true;
+    }
+
+    if (ext2 != nullptr) {
+        mExt2 = nw4r::g3d::ResFile(ext2);
+        mHasExt2 = true;
+    }
+
+    if (mHasExt1) {
+        mExt1.Bind(mMdlFile);
+    }
+
+    if (mHasExt2) {
+        mExt2.Bind(mMdlFile);
+    }
+
+    return true;
+}
+
+bool AnmMdlWrapper::create3(
+    dAcBase_c &ac, void *mdlFile, void *anmFile, const char *mdlName, const char *anmName,
+    m3d::mdl_c::mdlCallback_c *callback, u32 bufferOption
+) {
+    return create2(ac, mdlFile, anmFile, mdlName, anmName, callback, bufferOption);
+}
+
+bool AnmMdlWrapper2::setAnm(const char *anmFile, m3d::playMode_e mode, f32 frame) {
+    nw4r::g3d::ResAnmChr res = mAnmFile.GetResAnmChr(anmFile);
+    if (!res.IsValid()) {
+        if (mHasExt1) {
+            res = mExt1.GetResAnmChr(anmFile);
+            if (!res.IsValid()) {
+                if (mHasExt2) {
+                    res = mExt2.GetResAnmChr(anmFile);
+                    if (!res.IsValid()) {
+                        res = mMdlFile.GetResAnmChr(anmFile);
+                    }
+                }
+            }
+        }
+    }
+
+    mAnm.setAnm(mMdl, res, mode);
+    if (mMdl.setAnm(mAnm, frame)) {
+        return loadSounds(anmFile);
+    }
+    return false;
+}
+
+extern "C" f32 lbl_80575150;
+extern "C" f32 lbl_8057514C;
+extern "C" f32 lbl_80576A0C;
+
+void insertNode(SomeListNode *node, f32 a, f32 b) {
+    node->field_0x04 = ((a * lbl_80575150) - 0.5f) + lbl_8057514C;
+    node->field_0x06 = (lbl_80575150 - 0.5f) - b;
+    sSomeList.insert(node);
+}
+
+void clearList() {
+    // TODO
+    for (SomeList::Iterator it = sSomeList.GetBeginIter(); it != sSomeList.GetEndIter(); ++it) {
+        SomeListNode *nd = &*it;
+        SomeList::Iterator itCopy = sSomeList.GetPosition(nd);
+        sSomeList.remove(nd);
+        it = itCopy;
+    }
+}
+
+// More screen / list stuff...
+
+void unk2(nw4r::g3d::ResMat &mat, nw4r::g3d::ResMatTevColor &clr, LightingInfo *info) {
+    BlurAndPaletteManager &pllt = BlurAndPaletteManager::GetInstance();
+    const char *name = mat.GetName();
+    if (name != nullptr && name[0] == 'M' && name[1] == 'A' && name[2] == '0') {
+        char idx = name[3];
+        if (idx == '0') {
+            if (clr.IsValid()) {
+                clr.GXSetTevKColor(GX_KCOLOR3, pllt.GetCurrentDefaultMcf().MA00_kColor3);
+                clr.DCStore(false);
+                if (info != nullptr) {
+                    info->mTevK3Color = pllt.GetCurrentDefaultMcf().MA00_kColor3;
+                    info->mUseTevK3 = true;
+                }
+            }
+        } else if (idx == '1') {
+            if (clr.IsValid()) {
+                clr.GXSetTevColor(GX_TEVREG1, pllt.GetCurrentDefaultMcf().MA01_tevReg1);
+                clr.GXSetTevKColor(GX_KCOLOR2, pllt.GetCurrentDefaultMcf().MA01_kColor2);
+                clr.DCStore(false);
+                if (info != nullptr) {
+                    info->mTev1Color = pllt.GetCurrentDefaultMcf().MA01_tevReg1;
+                    info->mUseTev1 = true;
+                    info->mTevK2Color = pllt.GetCurrentDefaultMcf().MA01_kColor2;
+                    info->mUseTevK2 = true;
+                }
+            }
+        } else if (idx == '2') {
+            if (clr.IsValid()) {
+                clr.GXSetTevColor(GX_TEVREG1, pllt.GetCurrentDefaultMcf().MA02_tevReg1);
+                clr.GXSetTevKColor(GX_KCOLOR2, pllt.GetCurrentDefaultMcf().MA02_kColor2);
+                clr.DCStore(false);
+                if (info != nullptr) {
+                    info->mTev1Color = pllt.GetCurrentDefaultMcf().MA02_tevReg1;
+                    info->mUseTev1 = true;
+                    info->mTevK2Color = pllt.GetCurrentDefaultMcf().MA02_kColor2;
+                    info->mUseTevK2 = true;
+                }
+            }
+        } else if (idx == '3') {
+            if (clr.IsValid()) {
+                clr.GXSetTevKColor(GX_KCOLOR2, pllt.GetCurrentDefaultMcf().MA03_kColor3);
+                clr.DCStore(false);
+                if (info != nullptr) {
+                    info->mTevK3Color = pllt.GetCurrentDefaultMcf().MA03_kColor3;
+                    info->mUseTevK3 = true;
+                }
+            }
+        }
+        // TODO
+    }
+}
+
+void setRoomTevColors(nw4r::g3d::ResMdl mdl, int b1, bool bUnk) {
+    BlurAndPaletteManager &pllt = BlurAndPaletteManager::GetInstance();
+    SpawnInfo &spawn = dScGame_c::currentSpawnInfo;
+
+    for (u32 i = 0; i < mdl.GetResMatNumEntries(); i++) {
+        nw4r::g3d::ResMat mat = mdl.GetResMat(i);
+        nw4r::g3d::ResMatMisc misc = mat.GetResMatMisc();
+        nw4r::g3d::ResMatTevColor clr = mat.GetResMatTevColor();
+
+        unk2(mat, clr, nullptr);
+
+        nw4r::g3d::ResMat mat2 = mdl.GetResMat(i);
+        nw4r::g3d::ResTev tev = mat2.GetResTev();
+        // Apply false colors in trials
+        if (tev.IsValid() && spawn.getTrial() == SpawnInfo::TRIAL) {
+            if (pllt.get0x2DE8() == 0) {
+                if (!dTgSiren_c::isOutOfTime()) {
+                    // blue -> green
+                    tev.GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_GREEN, GX_CH_ALPHA);
+                    tev.DCStore(false);
+                } else {
+                    // red -> green, blue -> red
+                    tev.GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_GREEN, GX_CH_GREEN, GX_CH_RED, GX_CH_ALPHA);
+                    tev.DCStore(false);
+                }
+            } else {
+                // no change
+                tev.GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
+                tev.DCStore(false);
+            }
+        }
+
+        if (b1 == 1) {
+            misc.SetLightSetIdx(b1);
+        }
+        nw4r::g3d::ResMatChan chan = mat.GetResMatChan();
+        chan.GXSetChanAmbColor(GX_COLOR0, mColor(0xFF, 0xFF, 0xFF, 0xFF));
+    }
+}
+
+void UnkWithWater::calc(EGG::CpuTexture *tex) {
+    GXTexObj obj;
+    if (tex != nullptr) {
+        tex->GetTexObj(&obj);
+    }
+
+    for (NodeList::Iterator it = mList.GetBeginIter(); it != mList.GetEndIter(); ++it) {
+        it->apply(&obj);
+    }
+}
+
+bool UnkWithWater::init(nw4r::g3d::ResTexObj &obj, GXTexMapID mapId) {
+    UnkWithWaterNode *nd = new UnkWithWaterNode(obj, mapId);
+    if (nd == nullptr) {
+        return false;
+    }
+    mList.insert(nd);
+    return true;
+}
+
+void UnkWithWater::remove() {
+    // TODO register usage
+    NodeList::Iterator nextIt;
+    for (NodeList::Iterator it = mList.GetBeginIter(); it != mList.GetEndIter(); it = nextIt) {
+        nextIt = it;
+        ++nextIt;
+        UnkWithWaterNode *nd = &*it;
+        mList.remove(nd);
+        delete nd;
+    }
+}
+
+void UnkWithWaterNode::apply(const GXTexObj *obj) {
+    GXTexObj *o = mObj.GetTexObj(mMapId);
+    *o = *obj;
+}
+
+int EggTextureProc::entry() {
+    field_0x50 = field_0x51;
+    if (field_0x50) {
+        field_0x51 = (f32)field_0x50 * ((f32)field_0x52 / (f32)(field_0x52 + 1));
+        return m3d::scnLeaf_c::entry();
+    } else {
+        doRemove();
+        return 0;
+    }
+}
+
+void EggTextureProc::doDraw() {}
+
+void EggTextureProc::doRemove() {}
+
+bool EggTextureProc::create(int prioOpa, int prioXlu, mAllocator_c *alloc) {
+    if (!m3d::proc_c::create(alloc, nullptr)) {
+        return false;
+    }
+    if (prioOpa >= 0) {
+        setPriorityDraw(prioOpa, 0);
+        setOption(nw4r::g3d::ScnObj::OPTION_DISABLE_DRAW_XLU, true);
+    } else {
+        setPriorityDraw(0, prioXlu);
+        setOption(nw4r::g3d::ScnObj::OPTION_DISABLE_DRAW_OPA, true);
+    }
+    return true;
+}
+
+bool EggTextureProc::createXlu(int prioXlu, mAllocator_c *alloc) {
+    if (!m3d::proc_c::create(alloc, nullptr)) {
+        return false;
+    }
+
+    setPriorityDraw(0, prioXlu);
+    setOption(nw4r::g3d::ScnObj::OPTION_DISABLE_DRAW_OPA, true);
+
+    return true;
+}
+
+void XluProc::drawXlu() {
+    // TODO
+}
+
+} // namespace d3d

src/toBeSorted/d_scn_callback.cpp

@@ -0,0 +1,159 @@
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/d_bzs_types.h"
+#include "m/m3d/m3d.h"
+#include "nw4r/g3d/g3d_camera.h"
+#include "nw4r/g3d/g3d_scnmdl.h"
+#include "nw4r/g3d/g3d_scnmdlsmpl.h"
+#include "nw4r/g3d/g3d_scnobj.h"
+#include "nw4r/g3d/res/g3d_resmat.h"
+#include "nw4r/g3d/res/g3d_resmdl.h"
+#include "nw4r/g3d/res/g3d_respltt.h"
+#include "rvl/GX/GXTypes.h"
+#include "sized_string.h"
+#include "toBeSorted/d_d3d.h"
+#include "toBeSorted/stage_render_stuff.h"
+
+void dScnCallback_c::ExecCallback_CALC_MAT(nw4r::g3d::ScnObj::Timing, nw4r::g3d::ScnObj *obj, u32 param, void *pObj) {
+    const LightingInfo &info = mpActor->mLightingInfo;
+    mColor tev0 = info.mTev0Color;
+    mColor tev1 = info.mTev1Color;
+    mColor tev2 = info.mTev2Color;
+    mColor tevPrev = info.mTevPrevColor;
+    mColor tevK0 = info.mTevK0Color;
+    mColor tevK1 = info.mTevK1Color;
+    mColor tevK2 = info.mTevK2Color;
+    mColor tevK3 = info.mTevK3Color;
+
+    bool bTevK3 = false;
+    bool bTev0 = info.mUseTev0;
+    bool bTev1 = info.mUseTev1;
+    bool bTev2 = info.mUseTev2;
+    bool bTevPrev = info.mUseTevPrev;
+    bool bTevK0 = info.mUseTevK0;
+    bool bTevK1 = info.mUseTevK1;
+    bool bTevK2 = info.mUseTevK2;
+    if (!field_0x08 && info.mUseTevK3) {
+        bTevK3 = true;
+    }
+
+    nw4r::g3d::ScnMdl *pMdl = nw4r::g3d::ScnObj::DynamicCast<nw4r::g3d::ScnMdl>(obj);
+    if (pMdl != nullptr) {
+        nw4r::g3d::ResMdl resMdl = pMdl->GetResMdl();
+        for (u32 i = 0; i < resMdl.GetResMatNumEntries(); i++) {
+            nw4r::g3d::ScnMdl::CopiedMatAccess mat(pMdl, i);
+            nw4r::g3d::ResMatTevColor clr = mat.GetResMatTevColor(false);
+            if (bTev0) {
+                clr.GXSetTevColor(GX_TEVREG0, tev0);
+            }
+            if (bTevK0) {
+                clr.GXSetTevKColor(GX_KCOLOR0, tevK0);
+            }
+            if (bTevK3) {
+                clr.GXSetTevKColor(GX_KCOLOR3, tevK3);
+            }
+            if (bTev1) {
+                clr.GXSetTevColor(GX_TEVREG1, tev1);
+            }
+            if (bTev2) {
+                clr.GXSetTevColor(GX_TEVREG2, tev2);
+            }
+            if (bTevPrev) {
+                clr.GXSetTevColor(GX_TEVPREV, tevPrev);
+            }
+            if (bTevK1) {
+                clr.GXSetTevKColor(GX_KCOLOR1, tevK1);
+            }
+            if (bTevK2) {
+                clr.GXSetTevKColor(GX_KCOLOR2, tevK2);
+            }
+            clr.DCStore(false);
+        }
+        return;
+    }
+
+    nw4r::g3d::ScnMdlSimple *pMdlSimple = nw4r::g3d::ScnObj::DynamicCast<nw4r::g3d::ScnMdlSimple>(obj);
+
+    nw4r::g3d::ResMdl resMdl = pMdlSimple->GetResMdl();
+    for (u32 i = 0; i < resMdl.GetResMatNumEntries(); i++) {
+        nw4r::g3d::ResMat mat = resMdl.GetResMat(i);
+        nw4r::g3d::ResMatTevColor clr = mat.GetResMatTevColor();
+        if (bTev0) {
+            clr.GXSetTevColor(GX_TEVREG0, tev0);
+        }
+        if (bTevK0) {
+            clr.GXSetTevKColor(GX_KCOLOR0, tevK0);
+        }
+        if (bTevK3) {
+            clr.GXSetTevKColor(GX_KCOLOR3, tevK3);
+        }
+        if (bTev1) {
+            clr.GXSetTevColor(GX_TEVREG1, tev1);
+        }
+        if (bTev2) {
+            clr.GXSetTevColor(GX_TEVREG2, tev2);
+        }
+        if (bTevPrev) {
+            clr.GXSetTevColor(GX_TEVPREV, tevPrev);
+        }
+        if (bTevK1) {
+            clr.GXSetTevKColor(GX_KCOLOR1, tevK1);
+        }
+        if (bTevK2) {
+            clr.GXSetTevKColor(GX_KCOLOR2, tevK2);
+        }
+        clr.DCStore(false);
+    }
+}
+
+void dScnCallback_c::attach(m3d::scnLeaf_c &leaf) {
+    leaf.swapCallback(this);
+    leaf.enableCallbackTiming(nw4r::g3d::ScnObj::CALLBACK_TIMING_C);
+    leaf.enableCallbackOp(nw4r::g3d::ScnObj::EXECOP_CALC_MAT);
+}
+
+void setPCAMPos2(PCAM *pcam) {
+    static nw4r::g3d::Camera::PostureInfo sPosture = {
+        nw4r::g3d::Camera::POSTURE_AIM,
+        nw4r::math::VEC3(0.0f, 0.0f, 0.0f),
+        nw4r::math::VEC3(0.0f, 0.0f, 0.0f),
+        nw4r::math::VEC3(0.0f, 0.0f, 0.0f),
+        0.0f,
+    };
+
+    nw4r::g3d::Camera cam = m3d::getCamera(pcam->id);
+    cam.SetPosition(pcam->position1.x, pcam->position1.y, pcam->position1.z);
+    // TODO
+    sPosture.cameraTarget = pcam->position2;
+    cam.SetPosture(sPosture);
+    cam.SetOrtho(pcam->field_0x1C, -pcam->field_0x1C, -pcam->field_0x1C, pcam->field_0x1C, 1.0f, 1000000.0f);
+    cam.SetTexMtxParam(0.5f, 0.5f, 0.5f, 0.5f);
+}
+
+// TODO
+bool d3d::UnkWithWater::linkMdl(nw4r::g3d::ResMdl &mdl, d3d::UnkWithWater *thing) {
+    bool result = false;
+    
+    for (u32 i = 0; i < mdl.GetResMatNumEntries(); i++) {
+        nw4r::g3d::ResMat mat = mdl.GetResMat(i);
+        nw4r::g3d::ResTexSrt srt = mat.GetResTexSrt();
+
+        for (u32 j = 0; j < mat.GetNumResTexPlttInfo(); j++) {
+            nw4r::g3d::ResTexPlttInfo paletteInfo = mat.GetResTexPlttInfo(j);
+            const char *name = paletteInfo.GetTexName();
+            if (strequals(name, "DummyWater") || strequals(name, "TimeDoorB_Dummy")) {
+                nw4r::g3d::ResTexObj obj = mat.GetResTexObj();
+                thing->init(obj, paletteInfo.ptr()->mapID);
+                
+                u32 mode;
+                int camRef;
+                int lightRef;
+                srt.GetMapMode(j, &mode, &camRef, &lightRef);
+                srt.SetMapMode(j, mode, 0, lightRef);
+                result = true;
+            }
+        }
+    }
+
+    return result;
+}