m3d (#13)

* Initial M3d Pass
* `m_bmdl` and `m_bline` left

---------

Co-authored-by: elijah-thomas774 <elijahthomas774@gmail.com>
Co-authored-by: Elijah Thomas <42302100+elijah-thomas774@users.noreply.github.com>

src/REL/d/a/e/d_a_e_hb_leaf.cpp

@@ -0,0 +1,109 @@
+#include <d/a/e/d_a_e_hb_leaf.h>
+
+const f32 dAcEhb_leaf_c::unkFloat0 = 0.0f;
+const f32 dAcEhb_leaf_c::unkFloat1 = -0.0f;
+
+SPECIAL_ACTOR_PROFILE(E_HB_LEAF, dAcEhb_leaf_c, fProfile::E_HB_LEAF, 0x100, 0, 3);
+
+bool dAcEhb_leaf_c::createHeap() {
+    // This is ever so slightly weird but our m_anmMdl really doesn't take ResFile by value
+    // but only ever a single pointer.
+    void *fp = getOarcResFile("Degubaba");
+    TRY_CREATE(mModel.create(fp, "degubaba_leaf", "shake2", &heap_allocator, 0x123));
+    nw4r::g3d::ResFile f = fp;
+    nw4r::g3d::ResMdl mdl = f.GetResMdl("degubaba_leaf");
+    nw4r::g3d::ResAnmTexPat anm = f.GetResAnmTexPat("degubaba_leaf");
+    TRY_CREATE(mAnm.create(mdl, anm, &heap_allocator, nullptr, 1));
+    mModel.getModel().setAnm(mAnm);
+    return true;
+}
+
+int dAcEhb_leaf_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcEhb_leaf_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    setBoundingBox(mVec3_c(-100.0f, -100.0f, -100.0f), mVec3_c(100.0f, 100.0f, 100.0f));
+
+    rotation.y = cM::rndF(65535.0f);
+    someRot = rotation.y.mVal;
+
+    switch (getParam1()) {
+    case 0:
+    case 7:
+        mType = 0;
+        break;
+    case 1:
+        mType = 1;
+        break;
+    case 2:
+        mType = 2;
+        break;
+    case 3:
+    case 4:
+    case 5:
+        rotation.z = -0x8000;
+        break;
+    default:
+        break;
+    }
+
+    if (mType == 0) {
+        u32 param2 = getParam2();
+        if (param2 == 1) {
+            mType = 1;
+        } else if (param2 == 2) {
+            mType = 2;
+        }
+    }
+
+    if (mType == 2) {
+        field_0x3CC = 1;
+        someFloat = 1.0f;
+    }
+
+    if (mType != 0) {
+        actor_properties &= ~1;
+    }
+
+    mStartingPos = position;
+
+    return SUCCEEDED;
+}
+
+int dAcEhb_leaf_c::doDelete() {
+    return 1;
+}
+
+int dAcEhb_leaf_c::actorExecute() {
+    if (mType != 0) {
+        doCheck();
+        if (isNearZero()) {
+            return 1;
+        }
+    }
+
+    updateMatrix();
+    if (mType != 0) {
+        Mtx m;
+        PSMTXScale(m, someFloat, someFloat, someFloat);
+        PSMTXConcat(worldMatrix.m, m, worldMatrix.m);
+    }
+    mModel.getModel().setLocalMtx(worldMatrix);
+    mModel.getModel().calc(false);
+    someRot++;
+
+    return 1;
+}
+
+int dAcEhb_leaf_c::draw() {
+    if (!isHidden()) {
+        drawModelType1(&mModel.getModel());
+    }
+
+    return 1;
+}
+
+void dAcEhb_leaf_c::setAnm(const char *anm, f32 pos) {
+    mModel.setAnm(anm, m3d::PLAY_MODE_4, pos);
+}

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

@@ -0,0 +1,66 @@
+#include <d/a/obj/d_a_obj_lava_F200.h>
+#include <toBeSorted/room_manager.h>
+
+SPECIAL_ACTOR_PROFILE(OBJ_LAVA_F200, dAcOlavaF200_c, fProfile::OBJ_LAVA_F200, 0x0214, 0, 0);
+
+bool dAcOlavaF200_c::createHeap() {
+    mBrres = getOarcResFile("LavaF200");
+    RoomManager::bindStageResToFile(&mBrres);
+
+    nw4r::g3d::ResMdl mdl0 = mBrres.GetResMdl("LavaF200");
+    TRY_CREATE(mModels[0].create(mdl0, &heap_allocator, 0x32C));
+    nw4r::g3d::ResAnmTexSrt anmTex0 = mBrres.GetResAnmTexSrt("LavaF200");
+    TRY_CREATE(mTexAnms[0].create(mdl0, anmTex0, &heap_allocator, nullptr, 1));
+    nw4r::g3d::ResAnmClr anmClr0 = mBrres.GetResAnmClr("LavaF200");
+    TRY_CREATE(mClrAnms[0].create(mdl0, anmClr0, &heap_allocator, nullptr, 1));
+
+    nw4r::g3d::ResMdl mdl1 = mBrres.GetResMdl("LavaF200_s");
+    TRY_CREATE(mModels[1].create(mdl1, &heap_allocator, 0x32C));
+    nw4r::g3d::ResAnmTexSrt anmTex1 = mBrres.GetResAnmTexSrt("LavaF200_s");
+    TRY_CREATE(mTexAnms[1].create(mdl1, anmTex1, &heap_allocator, nullptr, 1));
+    nw4r::g3d::ResAnmClr anmClr1 = mBrres.GetResAnmClr("LavaF200_s");
+    TRY_CREATE(mClrAnms[1].create(mdl1, anmClr1, &heap_allocator, nullptr, 1));
+
+    return true;
+}
+
+int dAcOlavaF200_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOlavaF200_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mModels[0].setAnm(mTexAnms[0]);
+    mModels[1].setAnm(mTexAnms[1]);
+    mModels[0].setAnm(mClrAnms[0]);
+    mModels[1].setAnm(mClrAnms[1]);
+
+    updateMatrix();
+    for (int i = 0; i < 2; i++) {
+        mModels[i].setLocalMtx(worldMatrix);
+    }
+
+    mModels[0].setPriorityDraw(0x1C, 9);
+    mModels[1].setPriorityDraw(0x22, 9);
+    setBoundingBox(mVec3_c(-0.0f, -0.0f, -0.0f), mVec3_c(0.0f, 0.0f, 0.0f));
+
+    return SUCCEEDED;
+}
+
+int dAcOlavaF200_c::doDelete() {
+    return 1;
+}
+
+int dAcOlavaF200_c::actorExecute() {
+    mTexAnms[0].play();
+    mTexAnms[1].play();
+    mClrAnms[0].play();
+    mClrAnms[1].play();
+    return 1;
+}
+
+int dAcOlavaF200_c::draw() {
+    for (int i = 0; i < 2; i++) {
+        drawModelType1(&mModels[i]);
+    }
+    return 1;
+}

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

@@ -0,0 +1,120 @@
+#include <d/a/obj/d_a_obj_mole_soil.h>
+#include <s/s_Math.h>
+
+SPECIAL_ACTOR_PROFILE(OBJ_MOLE_SOIL, dAcOmoleSoil_c, fProfile::OBJ_MOLE_SOIL, 0x008B, 0, 6);
+
+STATE_DEFINE(dAcOmoleSoil_c, Wait);
+STATE_DEFINE(dAcOmoleSoil_c, Appear);
+STATE_DEFINE(dAcOmoleSoil_c, DisAppear);
+
+const f32 dAcOmoleSoil_c::sHalfScale = 0.5f;
+const f32 dAcOmoleSoil_c::sFullScale = 1.0f;
+
+bool dAcOmoleSoil_c::createHeap() {
+    nw4r::g3d::ResFile file = getOarcResFile("MogumaMud");
+    if (!file.mFile.IsValid()) {
+        return false;
+    }
+    mBrres = file;
+    nw4r::g3d::ResMdl mdl = mBrres.GetResMdl("MogumaMud");
+    TRY_CREATE(mModel.create(mdl, &heap_allocator, 0x120, 1, nullptr));
+    mModel.setPriorityDraw(0x1c, 9);
+    return true;
+}
+
+bool intToBool(int a) {
+    return a;
+}
+
+int dAcOmoleSoil_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOmoleSoil_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mScale = sHalfScale;
+    scale.set(sHalfScale, sHalfScale, sHalfScale);
+    mStateMgr.changeState(StateID_Wait);
+
+    setBoundingBox(mVec3_c(-100.0f, -0.0f, -100.0f), mVec3_c(100.0f, 100.0f, 100.0f));
+    return SUCCEEDED;
+}
+
+int dAcOmoleSoil_c::doDelete() {
+    return 1;
+}
+
+int dAcOmoleSoil_c::actorExecute() {
+    switch (getNextState()) {
+    case 1:
+        if (!mStateMgr.isState(StateID_Appear)) {
+            mStateMgr.changeState(StateID_Appear);
+        }
+        break;
+    case 2:
+        if (!mStateMgr.isState(StateID_DisAppear)) {
+            mStateMgr.changeState(StateID_DisAppear);
+        }
+        break;
+    case 3:
+        if (!mStateMgr.isState(StateID_Appear)) {
+            mStateMgr.changeState(StateID_Appear);
+        }
+        break;
+    }
+    mStateMgr.executeState();
+    updateMatrix();
+    mModel.setLocalMtx(worldMatrix);
+    return 1;
+}
+
+int dAcOmoleSoil_c::draw() {
+    if (field_0x391) {
+        drawModelType1(&mModel);
+    }
+    return 1;
+}
+
+void dAcOmoleSoil_c::initializeState_Wait() {
+    mDesiredNextState = 0;
+}
+void dAcOmoleSoil_c::executeState_Wait() {}
+void dAcOmoleSoil_c::finalizeState_Wait() {}
+
+void dAcOmoleSoil_c::initializeState_Appear() {
+    field_0x391 = true;
+}
+void dAcOmoleSoil_c::executeState_Appear() {
+    f32 stepSize = 0.05f;
+    if (sLib::chase(&mScale, sFullScale, stepSize)) {
+        mStateMgr.changeState(StateID_Wait);
+    } else {
+        mModel.setScale(mScale, mScale, mScale);
+    }
+}
+void dAcOmoleSoil_c::finalizeState_Appear() {
+    mDesiredNextState = 0;
+    mScale = sFullScale;
+    mModel.setScale(sFullScale, sFullScale, sFullScale);
+}
+
+void dAcOmoleSoil_c::initializeState_DisAppear() {
+    field_0x391 = true;
+}
+
+void dAcOmoleSoil_c::executeState_DisAppear() {
+    // Nothing about this makes sense but this creates the necessary casts
+    // and operations. Note that Ghidra constant-folds this despite
+    // all the stack operations for the cast.
+    int scalar = 0;
+    f32 stepSize = 0.01f * scalar + 0.05f;
+    if (sLib::chase(&mScale, sHalfScale, stepSize)) {
+        mStateMgr.changeState(StateID_Wait);
+    } else {
+        mModel.setScale(mScale, mScale, mScale);
+    }
+}
+void dAcOmoleSoil_c::finalizeState_DisAppear() {
+    mDesiredNextState = 0;
+    mScale = sHalfScale;
+    mModel.setScale(sHalfScale, sHalfScale, sHalfScale);
+}

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

@@ -0,0 +1,72 @@
+#include <d/a/obj/d_a_obj_ring.h>
+#include <d/d_player.h>
+
+SPECIAL_ACTOR_PROFILE(OBJ_RING, dAcOring_c, fProfile::OBJ_RING, 0x00f2, 0, 0x103);
+
+STATE_DEFINE(dAcOring_c, Move);
+
+bool dAcOring_c::createHeap() {
+    nw4r::g3d::ResFile f = getOarcResFile("PRing");
+    nw4r::g3d::ResMdl mdl = f.GetResMdl("PeehatRing");
+    // This matches but in a really weird way. Maybe an inline function?
+    TRY_CREATE(mModel.create(mdl, &heap_allocator, 0x20, 1, nullptr));
+    return true;
+}
+
+int dAcOring_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOring_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    field_0x388 = getArgFromParams();
+
+    setBoundingBox(mVec3_c(-100.0f, -100.0f, -100.0f), mVec3_c(100.0f, 100.0f, 100.0f));
+    updateMatrix();
+    mModel.setScale(scale);
+    mModel.setLocalMtx(worldMatrix);
+    forwardAccel = -5.0f;
+    forwardMaxSpeed = -40.0f;
+    field_0x38C = dPlayer::LINK->position.y;
+    mStateMgr.changeState(StateID_Move);
+    return SUCCEEDED;
+}
+
+int dAcOring_c::doDelete() {
+    return 1;
+}
+
+int dAcOring_c::actorExecute() {
+    mStateMgr.executeState();
+    calcVelocity();
+    position += velocity;
+    position += posIncrements;
+    updateMatrix();
+    mModel.setLocalMtx(worldMatrix);
+    return 1;
+}
+
+int dAcOring_c::draw() {
+    drawModelType1(&mModel);
+    return 1;
+}
+
+void dAcOring_c::initializeState_Move() {}
+
+u32 dAcOring_c::ROT_PER_TICK = 0x1000;
+
+void dAcOring_c::executeState_Move() {
+    bool isCarried = false;
+    if (mActorCarryInfo.isCarried == 1 && mActorCarryInfo.carryType == 7) {
+        isCarried = true;
+    }
+
+    if (isCarried) {
+        return;
+    }
+    rotation.x.mVal += ROT_PER_TICK;
+    if (field_0x38C >= position.y) {
+        deleteRequest();
+    }
+}
+
+void dAcOring_c::finalizeState_Move() {}

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

@@ -0,0 +1,60 @@
+#include <d/a/obj/d_a_obj_smoke.h>
+
+static const char *const sSmokeNames1[] = {
+        "SmokeF200",
+        "SmokeF202",
+};
+
+static const char *const sSmokeNames2[] = {
+        "SmokeF200",
+        "SmokeF202",
+};
+
+SPECIAL_ACTOR_PROFILE(OBJ_SMOKE, dAcOsmoke_c, fProfile::OBJ_SMOKE, 0x01DB, 0, 4);
+
+STATE_DEFINE(dAcOsmoke_c, Wait);
+
+bool dAcOsmoke_c::createHeap() {
+    mType = params & 3;
+    mBrres = getOarcResFile(sSmokeNames1[mType]);
+    nw4r::g3d::ResMdl mdl = mBrres.GetResMdl(sSmokeNames2[mType]);
+    TRY_CREATE(mModel.create(mdl, &heap_allocator, 0x324));
+    nw4r::g3d::ResAnmTexSrt srt = mBrres.GetResAnmTexSrt(sSmokeNames1[mType]);
+    TRY_CREATE(mTexAnm.create(mdl, srt, &heap_allocator, nullptr, 1));
+    return true;
+}
+
+int dAcOsmoke_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOsmoke_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mModel.setAnm(mTexAnm);
+    updateMatrix();
+    mModel.setLocalMtx(worldMatrix);
+    mStateMgr.changeState(StateID_Wait);
+    mModel.setPriorityDraw(0x1C, 9);
+    setBoundingBox(mVec3_c(-0.0f, -0.0f, -0.0f), mVec3_c(0.0f, 0.0f, 0.0f));
+    return SUCCEEDED;
+}
+
+int dAcOsmoke_c::doDelete() {
+    return 1;
+}
+
+int dAcOsmoke_c::actorExecute() {
+    mStateMgr.executeState();
+    mTexAnm.play();
+    return 1;
+}
+
+int dAcOsmoke_c::draw() {
+    drawModelType1(&mModel);
+    return 1;
+}
+
+void dAcOsmoke_c::initializeState_Wait() {}
+
+void dAcOsmoke_c::executeState_Wait() {}
+
+void dAcOsmoke_c::finalizeState_Wait() {}

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

@@ -0,0 +1,64 @@
+#include <d/a/obj/d_a_obj_sun_light.h>
+#include <toBeSorted/arc_managers/current_stage_arc_manager.h>
+#include <toBeSorted/room_manager.h>
+#include <toBeSorted/scgame.h>
+
+SPECIAL_ACTOR_PROFILE(OBJ_SUN_LIGHT, dAcOsunLight_c, fProfile::OBJ_SUN_LIGHT, 0x0219, 0, 3);
+
+STATE_DEFINE(dAcOsunLight_c, Wait);
+
+bool dAcOsunLight_c::createHeap() {
+    mBrres = CurrentStageArcManager::sInstance->getData("g3d/stage.brres");
+    RoomManager::bindStageResToFile(&mBrres);
+    RoomManager::bindSkyCmnToResFile(&mBrres);
+    nw4r::g3d::ResMdl mdl = mBrres.GetResMdl("StageF000Light");
+    TRY_CREATE(mModel.create(mdl, &heap_allocator, 0x120));
+    nw4r::g3d::ResAnmTexSrt srt = mBrres.GetResAnmTexSrt("StageF000Light");
+    TRY_CREATE(mTexAnm.create(mdl, srt, &heap_allocator, nullptr, 1));
+    return true;
+}
+
+int dAcOsunLight_c::create() {
+    if (!initAllocatorWork1Heap(-1, "dAcOsunLight_c::m_allocator", 0x20)) {
+        return FAILED;
+    }
+
+    mModel.setAnm(mTexAnm);
+    mStateMgr.changeState(StateID_Wait);
+    mModel.setPriorityDraw(0x1C, 9);
+    setBoundingBox(mVec3_c(-200.0f, -100.0f, -200.0f), mVec3_c(200.0f, 600.0f, 500.0f));
+    return SUCCEEDED;
+}
+
+int dAcOsunLight_c::doDelete() {
+    return 1;
+}
+
+int dAcOsunLight_c::actorExecute() {
+    mStateMgr.executeState();
+    if (isDay()) {
+        mTexAnm.play();
+    }
+    updateMatrix();
+    mModel.setLocalMtx(worldMatrix);
+    return 1;
+}
+
+int dAcOsunLight_c::draw() {
+    if (isDay()) {
+        drawModelType1(&mModel);
+    }
+    return 1;
+}
+
+void dAcOsunLight_c::initializeState_Wait() {}
+
+void dAcOsunLight_c::executeState_Wait() {}
+
+void dAcOsunLight_c::finalizeState_Wait() {}
+
+bool dAcOsunLight_c::isDay() {
+    // return !ScGame::currentSpawnInfo.isNight();
+    // TODO TempFix?
+    return !(u8)ScGame::currentSpawnInfo.night;
+}

src/REL/d/t/d_t_rock_boat.cpp

@@ -8,7 +8,7 @@ STATE_DEFINE(dTgRockBoat_c, Wait);
 int dTgRockBoat_c::create() {
     mStateMgr.changeState(StateID_Wait);
     cooldown = 1;
-    return 1;
+    return SUCCEEDED;
 }
 
 int dTgRockBoat_c::doDelete() {

src/REL/d/t/d_t_sound_area.cpp

@@ -40,7 +40,7 @@ int dTgSndAr_c::create() {
             ac->setBit_field_0xE8(params & 0xFF);
         }
     }
-    return 1;
+    return SUCCEEDED;
 }
 
 int dTgSndAr_c::doDelete() {

src/REL/d/t/d_t_sound_area_mgr.cpp

@@ -7,7 +7,7 @@ int dTgSndMg_c::create() {
     s8 tmpRoomId = roomid;
     addActorToRoom(-1);
     roomid = tmpRoomId;
-    return 1;
+    return SUCCEEDED;
 }
 
 int dTgSndMg_c::doDelete() {

src/REL/d/t/d_t_timer.cpp

@@ -27,7 +27,7 @@ int dTgTimer_c::create() {
         break;
     }
     resetTimer();
-    return 1;
+    return SUCCEEDED;
 }
 
 int dTgTimer_c::actorExecute() {

src/REL/d/t/d_t_tumble_weed.cpp

@@ -12,7 +12,7 @@ int dTgTumbleWeed_c::create() {
     tumbleweedTimer = 0;
     windTimer = 0x96;
     mStateMgr.changeState(StateID_AreaOut);
-    return 1;
+    return SUCCEEDED;
 }
 
 u16 decr(u16 *num);