Merge branch 'main' into 26-03-27-better-mapping

src/SSystem/SComponent/c_cc_d.cpp

@@ -6,6 +6,7 @@
 #include "SSystem/SComponent/c_cc_d.h"
 #include "JSystem/JUtility/JUTAssert.h"
 #include <cmath>
+#include "dusk/logging.h"
 
 #define CHECK_FLOAT_RANGE(line, x) JUT_ASSERT(line, -1.0e32f < x && x < 1.0e32f);
 
@@ -65,9 +66,23 @@ void cCcD_DivideArea::CalcDivideInfo(cCcD_DivideInfo* pDivideInfo, const cM3dGAa
         if (!mXDiffIsZero) {
             s32 var1 = mInvScaledXDiff * (aab.GetMinP()->x - GetMinP()->x);
             s32 var3 = mInvScaledXDiff * (aab.GetMaxP()->x - GetMinP()->x);
+#if TARGET_PC
+            // yDiv seems to be the problematic part here, but I clamped xDiv and zDiv too just in case.
+            // Unlike var1, var3 being greater than 31 isn't logged because it is every frame and the original code accounted for that.
+            // This goes for yDiv and zDiv as well.
+            if (var1 < 0 || var1 > 31) {
+                DuskLog.warn("CalcDivideInfo: xDiv var1 out of range: {}", var1);
+            }
+            if (var3 < 0) {
+                DuskLog.warn("CalcDivideInfo: xDiv var3 out of range: {}", var3);
+            }
+            var1 = var1 < 0 ? 0 : var1 > 31 ? 31 : var1;
+            var3 = var3 < 0 ? 0 : var3 > 31 ? 31 : var3;
+#else
             if (31 < var3) {
                 var3 = 31;
             }
+#endif
 
             xDivInfo = l_base[var3];
             if (0 < var1) {
@@ -81,9 +96,22 @@ void cCcD_DivideArea::CalcDivideInfo(cCcD_DivideInfo* pDivideInfo, const cM3dGAa
         if (!mYDiffIsZero) {
             s32 var1 = mInvScaledYDiff * (aab.GetMinP()->y - GetMinP()->y);
             s32 var3 = mInvScaledYDiff * (aab.GetMaxP()->y - GetMinP()->y);
+#if TARGET_PC
+            // When the Epona taming minigame starts as Wolf Link, yDiv var1 can be 32.
+            // When the Epona taming minigame ends, yDiv var1 and var3 can both be INT_MIN.
+            if (var1 < 0 || var1 > 31) {
+                DuskLog.warn("CalcDivideInfo: yDiv var1 out of range: {}", var1);
+            }
+            if (var3 < 0) {
+                DuskLog.warn("CalcDivideInfo: yDiv var3 out of range: {}", var3);
+            }
+            var1 = var1 < 0 ? 0 : var1 > 31 ? 31 : var1;
+            var3 = var3 < 0 ? 0 : var3 > 31 ? 31 : var3;
+#else
             if (31 < var3) {
                 var3 = 31;
             }
+#endif
 
             yDivInfo = l_base[var3];
             if (0 < var1) {
@@ -97,9 +125,20 @@ void cCcD_DivideArea::CalcDivideInfo(cCcD_DivideInfo* pDivideInfo, const cM3dGAa
         if (!mZDiffIsZero) {
             s32 var1 = mInvScaledZDiff * (aab.GetMinP()->z - GetMinP()->z);
             s32 var3 = mInvScaledZDiff * (aab.GetMaxP()->z - GetMinP()->z);
+#if TARGET_PC
+            if (var1 < 0 || var1 > 31) {
+                DuskLog.warn("CalcDivideInfo: zDiv var1 out of range: {}", var1);
+            }
+            if (var3 < 0) {
+                DuskLog.warn("CalcDivideInfo: zDiv var3 out of range: {}", var3);
+            }
+            var1 = var1 < 0 ? 0 : var1 > 31 ? 31 : var1;
+            var3 = var3 < 0 ? 0 : var3 > 31 ? 31 : var3;
+#else
             if (31 < var3) {
                 var3 = 31;
             }
+#endif
 
             zDivInfo = l_base[var3];
             if (0 < var1) {

src/SSystem/SComponent/c_m3d_g_cyl.cpp

@@ -6,6 +6,8 @@
 #include "SSystem/SComponent/c_m3d_g_cyl.h"
 #include "SSystem/SComponent/c_m3d.h"
 
+#include "JSystem/JUtility/JUTAssert.h"
+
 cM3dGCyl::cM3dGCyl(const cXyz* center, f32 radius, f32 height) {
     SetC(*center);
     SetR(radius);
@@ -24,21 +26,30 @@ void cM3dGCyl::Set(const cXyz& center, f32 radius, f32 height) {
     SetH(height);
 }
 
-void cM3dGCyl::SetC(const cXyz& center) {
-    mCenter = center;
+void cM3dGCyl::SetC(const cXyz& pos) {
+    JUT_ASSERT(67, !isnan(pos.x));
+    JUT_ASSERT(68, !isnan(pos.y));
+    JUT_ASSERT(69, !isnan(pos.z));
+
+    JUT_ASSERT(72, -1.0e32f < pos.x && pos.x < 1.0e32f && -1.0e32f < pos.y && pos.y < 1.0e32f && -1.0e32f < pos.z && pos.z < 1.0e32f);
+
+    mCenter = pos;
 }
 
-void cM3dGCyl::SetH(f32 height) {
-    mHeight = height;
+void cM3dGCyl::SetH(f32 h) {
+    JUT_ASSERT(82, !isnan(h));
+    JUT_ASSERT(83, -1.0e32f < h && h < 1.0e32f);
+    mHeight = h;
 }
 
-void cM3dGCyl::SetR(f32 radius) {
-    mRadius = radius;
+void cM3dGCyl::SetR(f32 r) {
+    JUT_ASSERT(106, !isnan(r));
+    JUT_ASSERT(107, -1.0e32f < r && r < 1.0e32f);
+    mRadius = r;
 }
 
 bool cM3dGCyl::cross(const cM3dGSph* other, cXyz* out) const {
-    f32 f;
-    return cM3d_Cross_CylSph(this, other, out, &f);
+    return cM3d_Cross_CylSph(this, other, out);
 }
 
 bool cM3dGCyl::cross(const cM3dGCyl* other, cXyz* out) const {

src/SSystem/SComponent/c_m3d_g_sph.cpp

@@ -6,8 +6,16 @@
 #include "SSystem/SComponent/c_m3d_g_sph.h"
 #include "SSystem/SComponent/c_m3d.h"
 
-void cM3dGSph::SetC(const cXyz& center) {
-    mCenter = center;
+#include "JSystem/JUtility/JUTAssert.h"
+
+void cM3dGSph::SetC(const cXyz& p) {
+    JUT_ASSERT(19, !isnan(p.x));
+    JUT_ASSERT(20, !isnan(p.y));
+    JUT_ASSERT(21, !isnan(p.z));
+
+    JUT_ASSERT(24, -1.0e32f < p.x && p.x < 1.0e32f && -1.0e32f < p.y && p.y < 1.0e32f && -1.0e32f < p.z && p.z < 1.0e32f);
+
+    mCenter = p;
 }
 
 void cM3dGSph::Set(const cXyz& center, f32 radius) {
@@ -20,8 +28,10 @@ void cM3dGSph::Set(const cM3dGSphS& other) {
     SetR(other.mRadius);
 }
 
-void cM3dGSph::SetR(f32 radius) {
-    mRadius = radius;
+void cM3dGSph::SetR(f32 r) {
+    JUT_ASSERT(54, !isnan(r));
+    JUT_ASSERT(55, -1.0e32f < r && r < 1.0e32f);
+    mRadius = r;
 }
 
 bool cM3dGSph::cross(const cM3dGSph* other, cXyz* out) const {

src/SSystem/SComponent/c_math.cpp

@@ -7,6 +7,7 @@
 #include "SSystem/SComponent/c_m3d.h"
 #include <cmath>
 #include <global.h>
+#include "dusk/logging.h"
 
 s16 cM_rad2s(f32 rad) {
     s32 s = (std::fmod(rad, 2 * M_PI) * (0x8000 / M_PI));
@@ -109,6 +110,13 @@ static u16 atntable[1025] = {
 
 u16 U_GetAtanTable(f32 f0, f32 f1) {
     int idx = f0 / f1 * 0x400;
+#if TARGET_PC
+    // When Wolf Link is playing a Human Link animation, idx can be INT_MIN every frame
+    if (idx < 0 || idx > 0x400) {
+        DuskLog.warn("U_GetAtanTable: idx out of range: {}", idx);
+    }
+    idx = idx < 0 ? 0 : idx > 0x400 ? 0x400 : idx;
+#endif
     return atntable[idx];
 }
 

src/Z2AudioCS/Z2AudioCS.cpp

@@ -127,12 +127,12 @@ SpkSoundHandle* Z2AudioCS::startLevel(s32 id, s32 chan) {
     return handle;
 }
 
-s32 Z2AudioCS::getName(s32 num) {
+const char* Z2AudioCS::getName(s32 num) {
     if (JASGlobalInstance<SpkSystem>::getInstance() == NULL) {
-        return 0;
+        return NULL;
     }
     if (JASGlobalInstance<SpkSystem>::getInstance()->getData() == NULL) {
-        return 0;
+        return NULL;
     }
 
     return JASGlobalInstance<SpkSystem>::getInstance()->getData()->getTableMgr().getName(num);

src/Z2AudioLib/Z2Audience.cpp

@@ -552,7 +552,11 @@ JAIAudible* Z2Audience::newAudible(const JGeometry::TVec3<f32>& pos, JAISoundID
 }
 
 void Z2Audience::deleteAudible(JAIAudible* audible) {
+#if TARGET_PC
+    JKR_DELETE(static_cast<Z2Audible*>(audible));
+#else
     JKR_DELETE(audible);
+#endif
 }
 
 Z2Audible::~Z2Audible() {}
@@ -798,7 +802,7 @@ f32 Z2Audience::calcFxMix_(f32 param_0, int distVolBit) const {
 
 f32 Z2Audience::calcPitch_(Z2AudibleChannel* channel, const Z2Audible* audible, const Z2AudioCamera* camera) const {
     JAUAudibleParam audParam = *audible->getAudibleParam();
-    if ((*(u8*)&audParam.field_0x0.raw >> 4) & 0xf) {
+    if (audParam.field_0x0.bytes.b0_0) {
         JGeometry::TVec3<f32> aTStack_4c;
         aTStack_4c.normalize(channel->field_0x14.field_0x00);
         JAUAudibleParam audParam = *audible->getAudibleParam();

src/Z2AudioLib/Z2AudioMgr.cpp

@@ -31,15 +31,15 @@ Z2AudioMgr::Z2AudioMgr() : mSoundStarter(true) {
 void Z2AudioMgr::init(JKRSolidHeap* heap, u32 memSize, void* baaData, JKRArchive* seqArc) {
     JAU_JASInitializer JASInitializer;
     JASInitializer.audioMemSize_ = memSize;
-    JASInitializer.field_0x1c = 140;
+    JASInitializer.mJasTrackPoolSize = 140;
     JASInitializer.dspLevel_ = 1.3f;
     JASInitializer.waveArcDir_ = "Audiores/Waves/";
     JASInitializer.initJASystem(heap);
 
     JAU_JAIInitializer JAIInitializer;
-    JAIInitializer.field_0x0 = 78;
-    JAIInitializer.field_0x4 = 4;
-    JAIInitializer.field_0xc = 48;
+    JAIInitializer.mJaiSePoolSize = 78;
+    JAIInitializer.mJaiSeqPoolSize = 4;
+    JAIInitializer.mJaiSoundChildPoolSize = 48;
     JAIInitializer.initJAInterface();
     
     JAISeMgr* seMgr = mSoundMgr.getSeMgr();
@@ -107,19 +107,6 @@ void Z2AudioMgr::init(JKRSolidHeap* heap, u32 memSize, void* baaData, JKRArchive
     JASPoolAllocObject<Z2SoundHandlePool>::newMemPool(0x4e);
     OS_REPORT("[Z2AudioMgr::init]before Create Section: %d\n", heap->getFreeSize());
 
-#if TARGET_PC
-    // Fix a race condition with OS threading where JAUNewSectionHeap will use all the remaining
-    // space in the JASDram heap before JASAudioThread has finished initializing.
-
-    OSLockMutex(&JASAudioThread::sThreadInitCompleteMutex);
-    while (!JASAudioThread::sThreadInitComplete) {
-        OSWaitCond(
-            &JASAudioThread::sThreadInitCompleteCond,
-            &JASAudioThread::sThreadInitCompleteMutex);
-    }
-    OSUnlockMutex(&JASAudioThread::sThreadInitCompleteMutex);
-#endif
-
     JAUSectionHeap* sectionHeap = JAUNewSectionHeap(true);
     sectionHeap->setSeqDataArchive(seqArc);
     size_t resMaxSize = JASResArcLoader::getResMaxSize(seqArc);
@@ -158,7 +145,7 @@ void Z2AudioMgr::init(JKRSolidHeap* heap, u32 memSize, void* baaData, JKRArchive
 }
 
 void Z2AudioMgr::setOutputMode(u32 mode) {
-    if (mode <= 2) {
+    if (mode <= JAS_OUTPUT_SURROUND) {
         JAISetOutputMode(mode);
     }
 }
@@ -168,7 +155,14 @@ void Z2AudioMgr::zeldaGFrameWork() {
     mSpeechMgr.framework();
     processSeFramework();
     processBgmFramework();
+
+    #if TARGET_PC
+    if (!dusk::getSettings().game.noLowHpSound) {
+        processHeartGaugeSound();
+    }
+    #else
     processHeartGaugeSound();
+    #endif
 
     #if DEBUG
     mDebugSys.debugframework();

src/Z2AudioLib/Z2Creature.cpp

@@ -211,11 +211,6 @@ Z2SoundHandlePool* Z2Creature::startCreatureSoundLevel(JAISoundID soundID, u32 m
 }
 
 Z2SoundHandlePool* Z2Creature::startCreatureVoice(JAISoundID soundID, s8 reverb) {
-    #if TARGET_PC
-        // stubbed
-        return nullptr;
-    #endif
-
     switch (soundID) {
     case Z2SE_MDN_V_FLY_OUT:
     case Z2SE_MDN_V_MGN_TAME:

src/Z2AudioLib/Z2SceneMgr.cpp

@@ -2018,10 +2018,6 @@ bool Z2SceneMgr::loadSceneWave(u32 wave, u32 bank) {
 #endif
 
 bool Z2SceneMgr::loadSeWave(u32 wave) {
-    return 0;
-}
-
-/* //lw stub lw 
     JAUSectionHeap* sectionHeap = JASGlobalInstance<JAUSectionHeap>::getInstance();
     JUT_ASSERT(3030, sectionHeap);
 
@@ -2036,13 +2032,8 @@ bool Z2SceneMgr::loadSeWave(u32 wave) {
     JUT_WARN_DEVICE(3038, 1, "Z2SceneMgr::cannot load SE wave:%d\n", wave);
     return false;
 }
-*/
+
 bool Z2SceneMgr::loadBgmWave(u32 wave) {
-    return true;
-}
-
-    /* //lw stub lw 
-
     JAUSectionHeap* sectionHeap = JASGlobalInstance<JAUSectionHeap>::getInstance();
     JUT_ASSERT(3047, sectionHeap);
 
@@ -2056,4 +2047,4 @@ bool Z2SceneMgr::loadBgmWave(u32 wave) {
 
     JUT_WARN_DEVICE(3055, 1, "Z2SceneMgr::cannot load BGM wave:%d\n", wave);
     return false;
-} */
+}

src/Z2AudioLib/Z2SoundHandles.cpp

@@ -40,7 +40,7 @@ Z2SoundHandlePool* Z2SoundHandles::getHandleSoundID(JAISoundID soundID) {
     return NULL;
 }
 
-Z2SoundHandlePool* Z2SoundHandles::getHandleUserData(u32 userData) {
+Z2SoundHandlePool* Z2SoundHandles::getHandleUserData(uintptr_t userData) {
     JSULink<Z2SoundHandlePool>* i;
     for (i = getFirst(); i != NULL; i = i->getNext()) {
         Z2SoundHandlePool* handle = i->getObject();

src/Z2AudioLib/Z2SoundObjMgr.cpp

@@ -107,6 +107,15 @@ static Z2EnemyInfo mEnemyInfo[64] = {
 void Z2SoundObjMgr::searchEnemy() {
     twilightBattle_ = 0;
 
+    #if TARGET_PC
+    if (Z2GetSeqMgr()->checkBgmIDPlaying(Z2BGM_MIDNA_SOS) &&
+        dusk::getSettings().game.midnasLamentNonStop)
+    {
+        Z2GetSeqMgr()->changeSubBgmStatus(0);
+        return;
+    }
+    #endif
+
     if (!Z2GetLink()) {
         Z2GetSeqMgr()->stopBattleBgm(1, 1);
         return;

src/Z2AudioLib/Z2SoundObject.cpp

@@ -502,7 +502,7 @@ void Z2SoundObjAnime::startSoundInner(const JGeometry::TVec3<f32>& pos, f32 para
     JUT_ASSERT(747, curSoundIndex_ < animation_->getNumSounds());
 
     const JAUSoundAnimationSound* animationSound = animation_->getSound(curSoundIndex_);
-    u32 user_data = (uintptr_t)animationSound;
+    uintptr_t user_data = (uintptr_t)animationSound;
     if (reverse_) {
         curSoundIndex_--;
     } else {

src/Z2AudioLib/Z2SoundPlayer.cpp

@@ -1,46 +1,55 @@
 #include "Z2AudioLib/Z2SoundPlayer.h"
-#include "Z2AudioLib/Z2SeqMgr.h"
+#include "Z2AudioLib/Z2AudioMgr.h"
+#include "Z2AudioCS/Z2AudioCS.h"
+#include "JSystem/JUtility/JUTGamePad.h"
 
-Z2SoundPlayer::Z2SoundPlayer(const char* param_1) : JAWWindow("Player for JAudio2", 500, 140), field_0x48c(field_0x46c, 8) {
-    field_0x3ed = 0;
-    field_0x3ee = 0;
-    field_0x3ef = 0;
-    field_0x3f0 = 0;
-    field_0x3f4 = param_1;
+Z2SoundPlayer::Z2SoundPlayer(const char* projectName)
+    : JAWWindow("Player for JAudio2", 500, 140),
+      field_0x48c(field_0x46c, 8)
+{
+    field_0x3ed = false;
+    field_0x3ee = false;
+    field_0x3ef = false;
+    field_0x3f0 = false;
+
+    m_name = projectName;
     field_0x3f8 = 0;
     field_0x3fc = 0;
     field_0x3fa = 0;
     field_0x3fe = 0;
     field_0x400 = 0;
-    field_0x402 = 0;
-    field_0x444 = 0;
+    m_portNum = 0;
+    m_portVal = 0;
     field_0x446 = 0;
-    field_0x404 = "CMD_PORT";
-    field_0x408 = "END_PORT";
-    field_0x40c = "STA_PORT";
-    field_0x410 = "WAIT_PORT";
-    field_0x414 = "NUM_PORT";
-    field_0x418 = "PORT_5";
-    field_0x41c = "MAP_PORT";
-    field_0x420 = "NOTE_PORT";
-    field_0x424 = "SE_SELECT_PORT";
-    field_0x428 = "BGM_STATUS_PORT";
-    field_0x42c = "BGM_PORT2";
-    field_0x430 = "BGM_PORT3";
-    field_0x434 = "PORT12";
-    field_0x438 = "PORT13";
-    field_0x43c = "FILTER_PORT";
-    field_0x440 = "FX_PORT";
+
+    m_portNames[0] = "CMD_PORT";
+    m_portNames[1] = "END_PORT";
+    m_portNames[2] = "STA_PORT";
+    m_portNames[3] = "WAIT_PORT";
+    m_portNames[4] = "NUM_PORT";
+    m_portNames[5] = "PORT_5";
+    m_portNames[6] = "MAP_PORT";
+    m_portNames[7] = "NOTE_PORT";
+    m_portNames[8] = "SE_SELECT_PORT";
+    m_portNames[9] = "BGM_STATUS_PORT";
+    m_portNames[10] = "BGM_PORT2";
+    m_portNames[11] = "BGM_PORT3";
+    m_portNames[12] = "PORT12";
+    m_portNames[13] = "PORT13";
+    m_portNames[14] = "FILTER_PORT";
+    m_portNames[15] = "FX_PORT";
+
     u8 r30 = 0;
     field_0x448[r30++] = &field_0x3f8;
     field_0x448[r30++] = &field_0x3fa;
     field_0x448[r30++] = &field_0x3fc;
     field_0x448[r30++] = &field_0x3fe;
     field_0x448[r30++] = &field_0x400;
-    field_0x448[r30++] = &field_0x402;
-    field_0x448[r30] = &field_0x444;
-    field_0x464 = 0;
-    field_0x468 = 7;
+    field_0x448[r30++] = &m_portNum;
+    field_0x448[r30] = &m_portVal;
+
+    m_cursorY = 0;
+    m_cursorMax = 7;
     field_0x4a0 = 0;
     field_0x4a4 = 1.0f;
     field_0x4a8 = 0.5f;
@@ -48,65 +57,446 @@ Z2SoundPlayer::Z2SoundPlayer(const char* param_1) : JAWWindow("Player for JAudio
     field_0x4b0 = 0.0f;
     field_0x4b4 = 0.0f;
     field_0x4b8 = 1.0f;
-    field_0x498 = Z2GetSeqMgr()->getSubBgmHandle();
+
+    mp_subBgmHandle = Z2GetSeqMgr()->getSubBgmHandle();
 }
 
-void Z2SoundPlayer::onDraw(JAWGraphContext*) {
+void Z2SoundPlayer::onDraw(JAWGraphContext* graf) {
+    JAUSoundNameTable* soundTable = JASGlobalInstance<JAUSoundNameTable>::getInstance();
+    
+    int var_r27 = 0;
+    if (field_0x3ed) {
+        var_r27 = 2;
+    }
 
+    u8 cursorY = 0;
+
+    graf->color(JUtility::TColor(0, 0x7F, 0xFF, 0xFF), JUtility::TColor(0, 0xFF, 0x7F, 0xFF));
+    graf->print(1, cursorY++, "Project: %s", m_name);
+
+    graf->color(0xFF >> (u8)var_r27, 0xFF >> (u8)var_r27, 0xFF >> (u8)var_r27, 0xFF);
+    graf->print(0, m_cursorY + 1, ">");
+
+    JUtility::TColor sp28(0xFF >> (u8)var_r27, 0xFF >> (u8)var_r27, 0xFF >> (u8)var_r27, 0xFF);
+    JUtility::TColor sp24(0, 0xFF >> (u8)var_r27, 0, 0xFF);
+
+    onDrawSoundItem(graf, soundTable, cursorY++,
+        sp28,
+        sp24,
+        "SEQ NUM ",
+        1, 0, field_0x3f8
+    );
+
+    graf->color(sp28);
+    const char* cateName;
+    if (soundTable != NULL) {
+        cateName = soundTable->getGroupName(JAISoundID(0, field_0x3fa & 0xFF, 0));
+    } else {
+        cateName = "";
+    }
+    graf->print(1, cursorY++, "SE CATE  %03x %s", field_0x3fa, cateName);
+
+    onDrawSoundItem(graf, soundTable, cursorY++,
+        sp28,
+        sp24,
+        "SE NUM  ",
+        0, field_0x3fa & 0xFF, field_0x3fc
+    );
+    onDrawSoundItem(graf, soundTable, cursorY++,
+        sp28,
+        sp24,
+        "STRM NUM",
+        2, 0, field_0x3fe
+    );
+
+    graf->color(sp28);
+    graf->print(1, cursorY++, "CORE_SPK %03x %s", field_0x400, Z2AudioCS::getName(field_0x400));
+
+    graf->color(field_0x446 + 0xC0, 0xC0, 0xC0, 0xFF);
+    graf->print(1, cursorY++, "PORT NUM %03x %s", m_portNum, m_portNames[m_portNum]);
+    graf->print(1, cursorY++, "PORT VAL %03x", m_portVal);
+
+    graf->color(0, 0x50, 0xC8, 0xFF);
+    if (field_0x3ee) {
+        graf->print(1, cursorY, "DOLBY ON\n");
+    }
+
+    graf->color(0xC8, 0x50, 0, 0xFF);
+    if (field_0x3f0) {
+        graf->print(10, cursorY, "LEVEL SE CALL");
+    }
+
+    graf->color(0xFF, 0, 0, 0xFF);
+    graf->print(0x16, cursorY, "%s", field_0x3ed ? "PAUSE ON" : "");
+
+    graf->color(0, 0xC8, (field_0x4a0 * 200) / 30, 0xFF);
+    if (field_0x3ef) {
+        graf->print(0x16, cursorY, "RESET %d\n", field_0x4a0);
+    }
 }
 
-void Z2SoundPlayer::onTrigA(const JUTGamePad&) {
+void Z2SoundPlayer::onTrigA(const JUTGamePad& pad) {
+    switch (m_cursorY) {
+    case 0: {
+        JAISoundID sp24(1, 0, (u16)field_0x3f8);
+        switch (sp24) {
+        case 0x100000a:
+        case 0x100000b:
+        case 0x100000f:
+        case 0x1000012:
+        case 0x1000014:
+        case 0x100001b:
+        case 0x100001c:
+        case 0x1000024:
+            Z2GetSoundMgr()->startSound(sp24, mp_subBgmHandle, NULL);
+            break;
+        default:
+            Z2GetSoundMgr()->startSound(sp24, &field_0x494, NULL);
+            break;
+        }
+        break;
+    }
+    case 1:
+    case 2:
+        if (!field_0x3f0) {
+            JAISoundHandle* handle = field_0x48c.getFreeHandle();
+            JAISoundID sp20(0, field_0x3fa & 0xFF, (u16)field_0x3fc);
+            if (handle != NULL) {
+                Z2GetSoundStarter()->startSound(sp20, handle, NULL);
+                if (*handle) {
+                    Z2GetSoundStarter()->setPortData(handle, m_portNum, m_portVal, -1);
+                }
+            }
+        }
+        break;
+    case 3:
+        Z2GetSoundMgr()->startSound(JAISoundID(2, 0, (u16)field_0x3fe), &field_0x49c, NULL);
+        break;
+    case 4:
+        if (!field_0x3f0) {
+            Z2AudioCS::start(field_0x400, 0);
+        }
+        break;
+    case 5:
+    case 6:
+        field_0x446 = 64;
+        if (m_portNum < 9) {
+            JAISoundHandle* handle = field_0x48c.getFreeHandle();
+            JAISoundID sp1C(0, field_0x3fa & 0xFF, (u16)field_0x3fc);
+            if (handle != NULL) {
+                Z2GetSoundStarter()->startSound(sp1C, handle, NULL);
+                if (*handle) {
+                    Z2GetSoundStarter()->setPortData(handle, m_portNum, m_portVal, -1);
+                }
+            }
+        } else {
+            if (field_0x494) {
+                Z2GetSoundStarter()->setPortData(&field_0x494, m_portNum, m_portVal, -1);
+            }
 
+            if (mp_subBgmHandle->isSoundAttached()) {
+                Z2GetSoundStarter()->setPortData(mp_subBgmHandle, m_portNum, m_portVal, -1);
+            }
+        }
+        break;
+    }
 }
 
-void Z2SoundPlayer::onTrigB(const JUTGamePad&) {
+void Z2SoundPlayer::onTrigB(const JUTGamePad& pad) {
+    switch (m_cursorY) {
+    case 0: {
+        if (field_0x494) {
+            field_0x494->stop(0);
+        }
 
+        field_0x494.releaseSound();
+
+        if (mp_subBgmHandle->isSoundAttached()) {
+            (*mp_subBgmHandle)->stop();
+        }
+        break;
+    }
+    case 1:
+    case 2: {
+        JAISoundHandle* handle = field_0x48c.getHandleSoundID(JAISoundID(0, field_0x3fa & 0xFF, (u16)field_0x3fc));
+        if (handle) {
+            (*handle)->stop();
+            handle->releaseSound();
+        }
+        break;
+    }
+    case 3:
+        if (field_0x49c) {
+            field_0x49c->stop();
+        }
+
+        field_0x49c.releaseSound();
+        break;
+    case 4:
+        Z2AudioCS::stop(0);
+        break;
+    case 5:
+    case 6:
+        m_portVal = 0;
+        field_0x446 = 0;
+
+        if (field_0x494) {
+            Z2GetSoundStarter()->setPortData(&field_0x494, m_portNum, m_portVal, -1);
+        }
+
+        if (mp_subBgmHandle->isSoundAttached()) {
+            Z2GetSoundStarter()->setPortData(mp_subBgmHandle, m_portNum, m_portVal, -1);
+        }
+        break;
+    }
 }
 
 void Z2SoundPlayer::frameWork() {
+    switch (m_cursorY) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+        break;
+    }
 
+    if (field_0x3ef) {
+        field_0x4a0++;
+
+        if (Z2GetAudioMgr()->hasReset()) {
+            Z2GetAudioMgr()->resetRecover();
+            field_0x3ef = false;
+            OS_REPORT("RESET END \n");
+        }
+    }
 }
 
-void Z2SoundPlayer::onPadProc(const JUTGamePad&) {
+void Z2SoundPlayer::onPadProc(const JUTGamePad& pad) {
+    if (field_0x3f0 && pad.testButton(PAD_BUTTON_A)) {
+        switch (m_cursorY) {
+        case 2: {
+            JAISoundID sp14(0, field_0x3fa & 0xFF, (u16)field_0x3fc);
+            JAISoundHandle* handle = field_0x48c.getHandleSoundID(sp14);
+            if (handle == NULL) {
+                handle = field_0x48c.getFreeHandle();
+            }
 
+            if (handle != NULL) {
+                Z2GetAudioMgr()->startLevelSound(sp14, handle, NULL);
+            }
+
+            if (*handle) {
+                Z2GetSoundStarter()->setPortData(handle, m_portNum, m_portVal, -1);
+            }
+            break;
+        }
+        case 4:
+            Z2AudioCS::startLevel(field_0x400, 0);
+            break;
+        }
+    }
 }
 
-void Z2SoundPlayer::onTrigX(const JUTGamePad&) {
+void Z2SoundPlayer::onTrigX(const JUTGamePad& pad) {
+    switch (m_cursorY) {
+    case 0: {
+        if (field_0x494) {
+            field_0x494->pause(!field_0x494->isPaused());
+        }
 
+        if (mp_subBgmHandle->isSoundAttached()) {
+            (*mp_subBgmHandle)->pause(!(*mp_subBgmHandle)->isPaused());
+        }
+        break;
+    }
+    case 1:
+    case 2: {
+        JAISoundHandle* handle = field_0x48c.getHandleSoundID(JAISoundID(0, field_0x3fa & 0xFF, (u16)field_0x3fc));
+        if (handle) {
+            (*handle)->pause(!(*handle)->isPaused());
+        }
+        break;
+    }
+    case 3:
+        if (field_0x49c) {
+            (field_0x49c)->pause(!(field_0x49c)->isPaused());
+        }
+        break;
+    case 4:
+        Z2AudioCS::stop(0);
+        break;
+    }
 }
 
-void Z2SoundPlayer::onTrigY(const JUTGamePad&) {
-
-
-}
-void Z2SoundPlayer::onTrigZ(const JUTGamePad&) {
-
-
-}
-void Z2SoundPlayer::onTrigL(const JUTGamePad&) {
-
+void Z2SoundPlayer::onTrigY(const JUTGamePad& pad) {
+    if (!field_0x3ef) {
+        Z2GetAudioMgr()->resetProcess(30, false);
+        field_0x3ef = true;
+        field_0x4a0 = 0;
+    }
 }
 
-void Z2SoundPlayer::onKeyLeft(const JUTGamePad&) {
-
+void Z2SoundPlayer::onTrigZ(const JUTGamePad& pad) {
+    bool* pvar = &field_0x3f0;
+    bool newValue = *pvar ^ 1;
+    *pvar = newValue;
 }
 
-void Z2SoundPlayer::onKeyRight(const JUTGamePad&) {
+void Z2SoundPlayer::onTrigL(const JUTGamePad& pad) {
+    bool* pvar = &field_0x3ee;
+    bool newValue = *pvar ^ 1;
+    *pvar = newValue;
 
+    if (field_0x3ee) {
+        Z2GetAudioMgr()->setOutputMode(2);
+    } else {
+        Z2GetAudioMgr()->setOutputMode(1);
+    }
 }
 
-void Z2SoundPlayer::onKeyUp(const JUTGamePad&) {
+void Z2SoundPlayer::onKeyLeft(const JUTGamePad& pad) {
+    int moveMax = getCursorMoveMax(pad);
+    int menuMax = getMenuNumberMax();
 
+    if (moveMax >= menuMax) {
+        moveMax = 1;
+    }
+
+    if (*field_0x448[m_cursorY] > moveMax - 1) {
+        *field_0x448[m_cursorY] -= (s16)moveMax;
+    } else {
+        *field_0x448[m_cursorY] = (*field_0x448[m_cursorY] + menuMax) - moveMax;
+    }
+
+    if (m_cursorY == 1) {
+        correctSeNumber();
+    }
 }
 
-void Z2SoundPlayer::onKeyDown(const JUTGamePad&) {
+void Z2SoundPlayer::onKeyRight(const JUTGamePad& pad) {
+    int moveMax = getCursorMoveMax(pad);
+    int menuMax = getMenuNumberMax();
 
+    if (moveMax >= menuMax) {
+        moveMax = 1;
+    }
+
+    if (*field_0x448[m_cursorY] < menuMax - moveMax) {
+        *field_0x448[m_cursorY] += (s16)moveMax;
+    } else {
+        *field_0x448[m_cursorY] = (*field_0x448[m_cursorY] + moveMax) - menuMax;
+    }
+
+    if (m_cursorY == 1) {
+        correctSeNumber();
+    }
 }
 
-void Z2SoundPlayer::onKeyMenu(const JUTGamePad&) {
-
+void Z2SoundPlayer::onKeyUp(const JUTGamePad& pad) {
+    if (m_cursorY != 0) {
+        m_cursorY--;
+    } else {
+        m_cursorY = m_cursorMax - 1;
+    }
 }
 
-u32 Z2SoundPlayer::getCursorMoveMax(const JUTGamePad&) {
-
+void Z2SoundPlayer::onKeyDown(const JUTGamePad& pad) {
+    if (m_cursorY < m_cursorMax - 1) {
+        m_cursorY++;
+    } else {
+        m_cursorY = 0;
+    }
+}
+
+void Z2SoundPlayer::onKeyMenu(const JUTGamePad& pad) {
+    bool* pvar = &field_0x3ed;
+    bool newValue = *pvar ^ 1;
+    *pvar = newValue;
+
+    Z2GetSoundMgr()->pauseAllGameSound(field_0x3ed);
+}
+
+u32 Z2SoundPlayer::getCursorMoveMax(const JUTGamePad& pad) {
+    u32 num = 1;
+
+    if (pad.testButton(PAD_TRIGGER_Z) && pad.testButton(PAD_BUTTON_X)) {
+        num = 128;
+    } else if (pad.testButton(PAD_TRIGGER_Z)) {
+        num = 16;
+    } else if (pad.testButton(PAD_BUTTON_X)) {
+        num = 8;
+    }
+
+    return num;
+}
+
+int Z2SoundPlayer::getMenuNumberMax() {
+    JAUSoundTable* soundTable = JASGlobalInstance<JAUSoundTable>::getInstance();
+    JUT_ASSERT(550, soundTable);
+
+    int num = 0;
+    switch (m_cursorY) {
+    case 0:
+        num = soundTable->getNumItems_inGroup(1, 0);
+        break;
+    case 1:
+        num = soundTable->getNumGroups_inSection(0);
+        break;
+    case 2:
+        num = soundTable->getNumItems_inGroup(0, field_0x3fa);
+        break;
+    case 3:
+        num = soundTable->getNumItems_inGroup(2, 0);
+        break;
+    case 4:
+        num = Z2AudioCS::getNumOfSound();
+        break;
+    case 5:
+        num = 16;
+        break;
+    case 6:
+        num = 128;
+        break;
+    }
+
+    return num;
+}
+
+void Z2SoundPlayer::correctSeNumber() {
+    JAUSoundTable* soundTable = JASGlobalInstance<JAUSoundTable>::getInstance();
+    JUT_ASSERT(594, soundTable);
+
+    int num = soundTable->getNumItems_inGroup(0, field_0x3fa);
+    if (num == 0) {
+        field_0x3fc = 0;
+    } else if (field_0x3fc >= num) {
+        field_0x3fc = num - 1;
+    }
+}
+
+void Z2SoundPlayer::onDrawSoundItem(JAWGraphContext* graf, JAUSoundNameTable* nameTable, int cursorY,
+                                    const JUtility::TColor& color0, const JUtility::TColor& color1,
+                                    const char* label, u32 sectionID, u32 groupID, u32 waveID)
+{
+    static const char szNoEntry[] = "(NO ENTRY)";
+
+    const char* soundName = "";
+    if (nameTable != NULL) {
+        soundName = nameTable->getName(JAISoundID(sectionID, groupID, waveID));
+        if (*soundName == 0) {
+            soundName = szNoEntry;
+        }
+    } else {
+        soundName = "";
+    }
+
+    // !@bug comparing strings directly instead of using strcmp
+    if (soundName == szNoEntry) {
+        graf->color(color1);
+    } else {
+        graf->color(color0);
+    }
+
+    graf->print(1, cursorY, "%s %03x %s", label, waveID, soundName);
 }

src/Z2AudioLib/Z2WaveArcLoader.cpp

@@ -0,0 +1,335 @@
+#include "Z2AudioLib/Z2WaveArcLoader.h"
+#include "JSystem/JAudio2/JAUSectionHeap.h"
+#include "JSystem/JAudio2/JASWaveInfo.h"
+
+#include <bitset>
+
+static f32 cStatusBar_X1 = 8.0f;
+static f32 cStatusBar_X2 = 16.0f;
+static f32 cWaveBar_X1 = 30.0f;
+static f32 cWaveBar_X2 = 80.0f;
+static f32 cBar_Y = 5.0f;
+static f32 cBarHeight = 310.0f;
+
+static u8 lbl_8074A738 = 10;
+static u8 lbl_8074A739 = 23;
+
+static u32 cWaveArcListSize = 10;
+
+Z2WaveArcLoader::Z2WaveArcLoader() :
+    JAWWindow("Z2WaveArcLoader", 420, 365)
+{
+    setWindowColor(0, 0, 0x50, 0xFF);
+
+    mpWaveBank = NULL;
+    mpWaveArc = NULL;
+    mWaveUsedSize = 0;
+    mTotalUsedSize = 0;
+    mBankNo = 0;
+    mArcCount = 0;
+    field_0x408 = 0;
+    field_0x40c = 0;
+    field_0x410 = 0;
+    field_0x414 = 0;
+    mIsLoadTail = false;
+
+    checkWaveBank();
+    checkWaveArc();
+}
+
+Z2WaveArcLoader::~Z2WaveArcLoader() {}
+
+// nonmatching with tree iterator stuff
+void Z2WaveArcLoader::onDraw(JAWGraphContext* graf) {
+    int cursorX = 8;
+    JASHeap* rootheap = JASWaveArcLoader::getRootHeap();
+    u32 aramsize = JASKernel::getAramSize();
+
+    mWaveUsedSize = 0;
+
+    for (u32 i = 0; i < 255; i++) {
+        JASWaveBank* bank = JASGlobalInstance<JAUSectionHeap>::getInstance()->getWaveBankTable().getWaveBank(i);
+        if (bank != NULL) {
+            u32 arcCount = bank->getArcCount();
+            for (int j = 0; j < arcCount; j++) {
+                JASWaveArc* arc = bank->getWaveArc(j);
+                if (arc != NULL && arc->getStatus() == 2) {
+                    mWaveUsedSize += arc->getFileSize();
+                }
+            }
+        }
+    }
+
+    u32 otherUsedSize = mTotalUsedSize - mWaveUsedSize;
+    u32 totalFree = rootheap->getTotalFreeSize();
+    u32 linearFreeSize = rootheap->getFreeSize();
+    u32 sp54 = totalFree - linearFreeSize;
+
+    graf->color(JUtility::TColor(0x32, 0x96, 0xFF, 0xFF), JUtility::TColor(0xC8, 0xC8, 0xFF, 0xFF));
+    graf->print(cursorX, 0, "ARAM STATUS\n");
+
+    graf->color(0xFF, 0xFF, 0xFF, 0xFF);
+    graf->print(cursorX, 1, " total used    : %8d\n", mTotalUsedSize);
+
+    graf->color(0xFF, 0x40, 0x40, 0xFF);
+    graf->print(cursorX, 2, "  wave used    : %8d\n", mWaveUsedSize);
+
+    graf->color(0xFF, 0xFF, 0x40, 0xFF);
+    graf->print(cursorX, 3, "  other used   : %8d\n", otherUsedSize);
+
+    graf->color(0x40, 0xFF, 0x40, 0xFF);
+    graf->print(cursorX, 4, "  linear free  : %8d\n", linearFreeSize);
+
+    graf->color(0xFF, 0xFF, 0xFF, 0xFF);
+    graf->print(cursorX, 5, " total free    : %8d\n", totalFree);
+    graf->print(cursorX, 6, " ------------------------\n");
+    graf->print(cursorX, 7, " aram size     : %8d\n", aramsize);
+
+    graf->color(0xFF, 0xFF, 0x20, 0xFF);
+    f32 var_f30 = cBar_Y;
+    f32 var_f31 = var_f30 + (((f32)otherUsedSize / (f32)aramsize) * cBarHeight);
+    graf->fillBox(JGeometry::TBox2<f32>(cStatusBar_X1, var_f30, cStatusBar_X2, var_f31));
+
+    graf->color(0xFF, 0x20, 0x20, 0xFF);
+    var_f30 = var_f31;
+    var_f31 += ((f32)mWaveUsedSize / (f32)aramsize) * cBarHeight;
+    graf->fillBox(JGeometry::TBox2<f32>(cStatusBar_X1, var_f30, cStatusBar_X2, var_f31));
+
+    graf->color(0x20, 0xFF, 0x20, 0xFF);
+    var_f30 = var_f31;
+    var_f31 += ((f32)linearFreeSize / (f32)aramsize) * cBarHeight;
+    graf->fillBox(JGeometry::TBox2<f32>(cStatusBar_X1, var_f30, cStatusBar_X2, var_f31));
+
+    graf->color(0x20, 0x20, 0xFF, 0xFF);
+    var_f30 = var_f31;
+    var_f31 += ((f32)sp54 / (f32)aramsize) * cBarHeight;
+    graf->fillBox(JGeometry::TBox2<f32>(cStatusBar_X1, var_f30, cStatusBar_X2, var_f31));
+
+    graf->color(0x40, 0x40, 0xFF, 0xFF);
+    graf->fillBox(JGeometry::TBox2<f32>(cWaveBar_X1, cBar_Y, cWaveBar_X2, cBar_Y + cBarHeight));
+
+    void* pbase = rootheap->getBase();
+    u32 heapSize = rootheap->getSize();
+    int sp48 = 0;
+
+    mTotalUsedSize = 0;
+
+    for (JSUTreeIterator<JASHeap> i = rootheap->getFirstChild(); (int)i != (int)rootheap->getEndChild(); ++i) {
+        intptr_t sp40 = (char*)i->getBase() - (char*)pbase;
+        u32 sp3C = i->getSize();
+        mTotalUsedSize += sp3C;
+
+        int sp38 = (sp40 * cBarHeight) / heapSize;
+        int sp34 = (sp3C * cBarHeight) / heapSize;
+        JGeometry::TBox2<f32> spD0(cWaveBar_X1, cBar_Y + (f32)sp38, cWaveBar_X2, (f32)sp34 + (cBar_Y + (f32)sp38));
+        u8 sp9 = 0xFF;
+        sp9 = sp48 % 2 ? (u8)0xC0 : (u8)0x80;
+        graf->color(0xFF, sp9, 0x40, 0xFF);
+        graf->fillBox(spD0);
+
+        if (mpWaveArc != NULL) {
+            if (mpWaveArc->getHeap() == i.getObject()) {
+                graf->color(0xFF, 0xFF, 0xFF, 0xFF);
+                graf->lineWidth(15);
+                graf->drawFrame(spD0);
+            }
+        }
+
+        sp48++;
+    }
+
+    graf->color(JUtility::TColor(0xC8, 0xC8, 0xFF, 0xFF), JUtility::TColor(0x32, 0x96, 0xFF, 0xFF));
+    if (mIsLoadTail) {
+        graf->print(cursorX, 9, "WAVE BANK    LOAD:Tail");
+    } else {
+        graf->print(cursorX, 9, "WAVE BANK    LOAD:Linear");
+    }
+
+    int var_r26 = lbl_8074A738;
+
+    if (mpWaveBank == NULL) {
+        graf->color(0x64, 0x64, 0x64, 0xFF);
+        graf->print(cursorX, var_r26, " ws:%3d Not Registerd", mBankNo);
+
+        graf->color(0xFF, 0xFF, 0xFF, 0xFF);
+        graf->print(cursorX, var_r26, ">");
+    } else {
+        graf->color(0xFF, 0xFF, 0xFF, 0xFF);
+        if (field_0x414 < 2) {
+            graf->print(cursorX, field_0x414 + var_r26, ">");
+        } else {
+            graf->print(cursorX, field_0x414 + (var_r26 + 1), ">");
+        }
+
+        graf->print(cursorX, var_r26++, " ws:%3d", mBankNo);
+        graf->print(cursorX, var_r26++, " aw:%3d-%3d /%3d", field_0x40c, field_0x410, mArcCount - 1);
+
+        graf->color(0xFF, 0xA0, 0x64, 0xFF);
+        graf->print(cursorX, var_r26++, "      aw_status  aw_size");
+
+        graf->color(0xFF, 0xFF, 0xFF, 0xFF);
+
+        for (int i = field_0x40c; i < field_0x410 + 1; i++) {
+            JASWaveArc* arc = mpWaveBank->getWaveArc(i);
+            if (arc == NULL) {
+                break;
+            }
+
+            switch (arc->getStatus()) {
+            case 0:
+                graf->color(0x64, 0x64, 0x64, 0xFF);
+                graf->print(cursorX, var_r26, "%3d:  NOT_LOAD  %8d", i, arc->getFileSize());
+                break;
+            case 1:
+                graf->color(0xFF, 0x64, 0x64, 0xFF);
+                graf->print(cursorX, var_r26, "%3d:  WAIT_LOAD %8d", i, arc->getFileSize());
+                break;
+            case 2:
+                graf->color(0xFF, 0xFF, 0xC8, 0xFF);
+                graf->print(cursorX, var_r26, "%3d:  LOAD      %8d", i, arc->getFileSize());
+                break;
+            }
+
+            var_r26++;
+        }
+    }
+
+    var_r26 = lbl_8074A739;
+    graf->color(0x96, 0x96, 0xE1, 0xFF);
+    graf->print(cursorX, var_r26++, "-----------------");
+    graf->print(cursorX, var_r26++, " A ->  LOAD WAVE");
+    graf->print(cursorX, var_r26++, " B -> ERASE WAVE");
+    graf->print(cursorX, var_r26++, "-----------------");
+}
+
+void Z2WaveArcLoader::checkWaveBank() {
+    JAUSectionHeap* sectionHeap = JASGlobalInstance<JAUSectionHeap>::getInstance();
+    const JAUSectionHeap::TSectionHeapData& heapData = sectionHeap->getSectionHeapData();
+    const JAUSection::TSectionData& sectionData = sectionHeap->getSectionData();
+
+    if (sectionData.registeredWaveBankTables.test(mBankNo)) {
+        mpWaveBank = heapData.waveBankTable.getWaveBank(mBankNo);
+        mArcCount = mpWaveBank->getArcCount();
+    } else {
+        mpWaveBank = NULL;
+        mArcCount = 0;
+    }
+
+    if (mBankNo == 1) {
+        mIsLoadTail = true;
+    } else {
+        mIsLoadTail = false;
+    }
+}
+
+void Z2WaveArcLoader::checkWaveArc() {
+    field_0x40c = field_0x408 * cWaveArcListSize;
+    if (field_0x40c > mArcCount - 1) {
+        field_0x408--;
+        field_0x40c = field_0x408 * cWaveArcListSize;
+    }
+
+    field_0x410 = (field_0x408 + 1) * cWaveArcListSize - 1;
+
+    if (field_0x410 > mArcCount - 1) {
+        field_0x410 = mArcCount - 1;
+    }
+
+    if (field_0x414 > 1) {
+        if ((field_0x40c + field_0x414) - 2 > field_0x410) {
+            field_0x414 = (field_0x410 - field_0x40c) + 2;
+        }
+
+        mpWaveArc = mpWaveBank->getWaveArc(field_0x40c + field_0x414 - 2);
+    } else {
+        mpWaveArc = NULL;
+    }
+}
+
+void Z2WaveArcLoader::onKeyUp(const JUTGamePad&) {
+    if (mpWaveBank == NULL) {
+        field_0x414 = 0;
+    } else {
+        if (field_0x414 != 0) {
+            field_0x414--;
+        } else {
+            field_0x414 = 11;
+        }
+
+        checkWaveArc();
+    }
+}
+
+void Z2WaveArcLoader::onKeyDown(const JUTGamePad&) {
+    if (mpWaveBank == NULL) {
+        field_0x414 = 0;
+    } else {
+        if (field_0x414 < 11) {
+            field_0x414++;
+        } else {
+            field_0x414 = 0;
+        }
+
+        checkWaveArc();
+    }
+}
+
+void Z2WaveArcLoader::onKeyLeft(const JUTGamePad&) {
+    if (field_0x414 == 0) {
+        if (mBankNo != 0) {
+            mBankNo--;
+        } else {
+            mBankNo = 0;
+        }
+
+        checkWaveBank();
+    } else if (mpWaveBank != NULL) {
+        if (field_0x408 != 0) {
+            field_0x408--;
+        } else {
+            field_0x408 = 0;
+        }
+
+        checkWaveArc();
+    }
+}
+
+void Z2WaveArcLoader::onKeyRight(const JUTGamePad&) {
+    if (field_0x414 == 0) {
+        if (mBankNo < 255) {
+            mBankNo++;
+        } else {
+            mBankNo = 255;
+        }
+
+        checkWaveBank();
+    } else if (mpWaveBank != NULL) {
+        if (field_0x408 < 255) {
+            field_0x408++;
+        } else {
+            field_0x408 = 255;
+        }
+
+        checkWaveArc();
+    }
+}
+
+void Z2WaveArcLoader::onTrigA(const JUTGamePad&) {
+    if (mpWaveArc != NULL && mpWaveArc->getStatus() == 0) {
+        if (mIsLoadTail) {
+            mpWaveArc->loadTail(NULL);
+        } else {
+            mpWaveArc->load(NULL);
+        }
+    }
+}
+
+void Z2WaveArcLoader::onTrigB(const JUTGamePad&) {
+    if (mpWaveArc != NULL && mpWaveArc->getStatus() == 2) {
+        mpWaveArc->erase();
+    }
+}
+
+void Z2WaveArcLoader::onTrigZ(const JUTGamePad&) {
+    mIsLoadTail = !mIsLoadTail;
+}

src/d/actor/d_a_alink.cpp

@@ -1467,7 +1467,7 @@ static f32 l_ladderAnmBaseTransY = 102.00054168701172f;
 
 static dCcD_SrcCyl l_cylSrc = {
     {
-        {0, {{AT_TYPE_WOLF_ATTACK, 3, 0x1A}, {0xD8FFFDFF, 5}, 0x73}},
+        {0, {{(u32)AT_TYPE_WOLF_ATTACK, 3, 0x1A}, {0xD8FFFDFF, 5}, 0x73}},
         {dCcD_SE_WOLF_BITE, 3, 1, 0, {1}},
         {dCcD_SE_NONE, 6, 0, 0, {0}},
         {0},
@@ -7509,6 +7509,11 @@ void daAlink_c::setBlendMoveAnime(f32 i_morf) {
     f32 sp28 = mpHIO->mMove.m.mFootPositionRatio;
     BOOL sp24 = checkEventRun();
     BOOL sp20 = checkBootsMoveAnime(1);
+#if TARGET_PC
+    if (dusk::getSettings().game.enableFastIronBoots) {
+        sp20 = FALSE;
+    }
+#endif
 
     f32 var_f29;
 
@@ -9469,6 +9474,11 @@ void daAlink_c::setStickData() {
             } else {
                 mHeavySpeedMultiplier = mpHIO->mItem.mIronBoots.m.mInputFactor;
             }
+#if TARGET_PC
+            if (dusk::getSettings().game.enableFastIronBoots) {
+                mHeavySpeedMultiplier = 1.0f;
+            }
+#endif
             mStickValue *= mHeavySpeedMultiplier;
         } else if (checkBootsOrArmorHeavy()) {
             if (checkZoraWearAbility()) {
@@ -9476,6 +9486,11 @@ void daAlink_c::setStickData() {
             } else {
                 mHeavySpeedMultiplier = mpHIO->mItem.mIronBoots.m.mWaterInputFactor;
             }
+#if TARGET_PC
+            if (dusk::getSettings().game.enableFastIronBoots) {
+                mHeavySpeedMultiplier = 1.0f;
+            }
+#endif
             mStickValue *= mHeavySpeedMultiplier;
         } else if ((checkWolf() && field_0x2fbc == 11 && checkWaterPolygonUnder()) ||
                    mGndPolyAtt0 == 11)
@@ -12662,7 +12677,11 @@ void daAlink_c::setMagicArmorBrk(int i_status) {
 }
 
 BOOL daAlink_c::checkMagicArmorHeavy() const {
+#if TARGET_PC
+    return checkMagicArmorWearAbility() && (dComIfGs_getRupee() == 0 && !dusk::getSettings().game.freeMagicArmor);
+#else
     return checkMagicArmorWearAbility() && dComIfGs_getRupee() == 0;
+#endif
 }
 
 BOOL daAlink_c::checkBootsOrArmorHeavy() const {
@@ -18568,7 +18587,13 @@ int daAlink_c::execute() {
             field_0x372c = cXyz::Zero;
             field_0x2fb8 = 0;
 
+#if TARGET_PC
+            // This handles rupee drain and transitions between rupees/no rupees
+            // We can skip all of that if the magic armor doesn't use rupees
+            if (!dusk::getSettings().game.freeMagicArmor && checkMagicArmorWearAbility() && mClothesChangeWaitTimer == 0) {
+#else
             if (checkMagicArmorWearAbility() && mClothesChangeWaitTimer == 0) {
+#endif
                 if (checkMagicArmorNoDamage() && !checkEventRun()) {
                     if (field_0x2fc3 == 0) {
                         field_0x2fc3 = 10;

src/d/actor/d_a_alink_cut.inc

@@ -7,6 +7,8 @@
 #include "d/actor/d_a_b_gnd.h"
 #include "SSystem/SComponent/c_math.h"
 
+#include "dusk/settings.h"
+
 enum daAlink_CutNmParamType {
     CUT_NM_PARAM_VERTICAL,
     CUT_NM_PARAM_LEFT,
@@ -369,6 +371,12 @@ BOOL daAlink_c::changeCutReverseProc(daAlink_c::daAlink_ANM i_anmID) {
         return procCutReverseInit(i_anmID);
     }
 
+    #if TARGET_PC
+    if (dusk::getSettings().game.noSwordRecoil) {
+        return FALSE;
+    }
+    #endif
+
     if (checkNoResetFlg0(FLG0_CUT_AT_FLG) || mEquipItem == dItemNo_COPY_ROD_e) {
         cXyz sp28;
         Vec sp1C;

src/d/actor/d_a_alink_damage.inc

@@ -152,6 +152,13 @@ f32 daAlink_c::damageMagnification(BOOL i_checkZoraMag, int param_1) {
         base_mag = 1.0f;
     }
 
+    #if TARGET_PC
+    base_mag *= dusk::getSettings().game.damageMultiplier;
+    if (dusk::getSettings().game.instantDeath) {
+        base_mag = 9999.0f;
+    }
+    #endif
+
     if (checkWolf() && !checkCargoCarry() && param_1 == 0) {
         return 2.0f * base_mag;
     }
@@ -180,6 +187,11 @@ int daAlink_c::setDamagePoint(int i_dmgAmount, BOOL i_checkZoraMag, BOOL i_setDm
     }
 
     if (checkMagicArmorNoDamage()) {
+#if TARGET_PC
+        if(dusk::getSettings().game.freeMagicArmor) {
+            i_dmgAmount = 0;
+        }
+#endif
         dComIfGp_setItemRupeeCount(-i_dmgAmount * 10);
     } else
     #if DEBUG

src/d/actor/d_a_alink_demo.inc

@@ -23,6 +23,8 @@
 #include "d/actor/d_a_npc_tkc.h"
 #include <cstring>
 
+#include "dusk/settings.h"
+
 BOOL daAlink_c::checkEventRun() const {
     return dComIfGp_event_runCheck() || checkPlayerDemoMode();
 }
@@ -2230,6 +2232,12 @@ void daAlink_c::setGetSubBgm(int i_itemNo) {
 }
 
 BOOL daAlink_c::checkTreasureRupeeReturn(int i_itemNo) const {
+    #if TARGET_PC
+    if (dusk::getSettings().game.noReturnRupees) {
+        return FALSE;
+    }
+    #endif
+
     static const int dummy = 0;
 
     if (i_itemNo == dItemNo_LINKS_SAVINGS_e) {
@@ -4290,7 +4298,7 @@ static fopAc_ac_c* daAlink_searchPortal(fopAc_ac_c* i_actor, void* i_data) {
 }
 
 bool daAlink_c::checkAcceptWarp() {
-    #if VERSION != VERSION_WII_USA_R0
+    #if TARGET_PC || VERSION != VERSION_WII_USA_R0
     cM3dGPla plane;
     #endif
 
@@ -4298,7 +4306,9 @@ bool daAlink_c::checkAcceptWarp() {
      * Fixed in versions above Wii USA Rev 0 by checking FLG0_WATER_IN_MOVE
      */
     if (mLinkAcch.ChkGroundHit() && !checkModeFlg(MODE_PLAYER_FLY)
-        #if VERSION != VERSION_WII_USA_R0
+        #if TARGET_PC
+        && (dusk::getSettings().game.restoreWiiGlitches || !checkNoResetFlg0(FLG0_WATER_IN_MOVE))
+        #elif VERSION != VERSION_WII_USA_R0
         && !checkNoResetFlg0(FLG0_WATER_IN_MOVE)
         #endif
        )
@@ -4307,7 +4317,9 @@ bool daAlink_c::checkAcceptWarp() {
          * Fixed in versions above Wii USA Rev 0 by checking getSlidePolygon
          */
         if (
-            #if VERSION != VERSION_WII_USA_R0
+            #if TARGET_PC
+            (dusk::getSettings().game.restoreWiiGlitches || !getSlidePolygon(&plane)) &&
+            #elif VERSION != VERSION_WII_USA_R0
             !getSlidePolygon(&plane) &&
             #endif
             !checkForestOldCentury()

src/d/actor/d_a_alink_dusk.cpp

@@ -0,0 +1,78 @@
+#include "d/actor/d_a_alink.h"
+#include "d/actor/d_a_midna.h"
+#include "d/d_meter2.h"
+#include "d/d_meter2_draw.h"
+#include "d/d_meter2_info.h"
+
+void daAlink_c::handleQuickTransform() {
+    if (!dusk::getSettings().game.enableQuickTransform) {
+        return;
+    }
+
+    // Ensure that link is not in a cutscene.
+    if (checkEventRun()) {
+        return;
+    }
+
+    // Check to see if Link has the ability to transform.
+    if (!dComIfGs_isEventBit(dSv_event_flag_c::M_077)) {
+        return;
+    }
+
+    // Ensure there is a proper pointer to the mMeterClass and mpMeterDraw structs in g_meter2_info.
+    const auto meterClassPtr = g_meter2_info.getMeterClass();
+    if (!meterClassPtr) {
+        return;
+    }
+
+    const auto meterDrawPtr = meterClassPtr->getMeterDrawPtr();
+    if (!meterDrawPtr) {
+        return;
+    }
+
+    mDoCPd_c::getCpadInfo(PAD_1).mPressedButtonFlags = 0;
+
+    // Ensure that the Z Button is not dimmed
+    if (meterDrawPtr->getButtonZAlpha() != 1.f) {
+        Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
+        return;
+    }
+
+    // The game will crash if trying to quick transform while holding the Ball and Chain
+    if (mEquipItem == dItemNo_IRONBALL_e) {
+        Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
+        return;
+    }
+
+    // Use the game's default checks for if the player can currently transform
+    if (!m_midnaActor->checkMetamorphoseEnableBase()) {
+        Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
+        return;
+    }
+
+    bool canTransform = false;
+
+    if (mLinkAcch.ChkGroundHit() && !checkModeFlg(MODE_PLAYER_FLY) && !checkMagneBootsOn()) {
+        if (!checkForestOldCentury()) {
+            if (checkMidnaRide()) {
+                if ((checkWolf() &&
+                     (checkModeFlg(MODE_UNK_1000) || dComIfGp_checkPlayerStatus0(0, 0x10))) ||
+                    (!checkWolf() &&
+                     (checkEventRun() || getMidnaActor()->checkMetamorphoseEnable()) &&
+                     (checkModeFlg(4) || dComIfGp_checkPlayerStatus0(0, 0x10))))
+                {
+                    canTransform = true;
+                }
+            }
+        }
+    }
+
+    if (!canTransform)
+    {
+        Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
+        return;
+    }
+
+    OSReport("Running quick transform!");
+    procCoMetamorphoseInit();
+}

src/d/actor/d_a_alink_effect.inc

@@ -1562,6 +1562,10 @@ void daAlink_c::setMetamorphoseEffectStartLink() {
         emitter->setGlobalParticleScale(effScale);
     }
     #endif
+
+    #if TARGET_PC
+    emitter->setGlobalParticleScale(mDoGph_gInf_c::getScale(), 1.0f);
+    #endif
 }
 
 void daAlink_c::setMetamorphoseEffect() {

src/d/actor/d_a_alink_hang.inc

@@ -13,8 +13,15 @@
 #include "d/actor/d_a_obj_swhang.h"
 
 f32 daAlink_c::getHangMoveAnmSpeed() {
+    #if TARGET_PC
+    return getAnmSpeedStickRate(
+        dusk::getSettings().game.fastClimbing ? 2.0f : mpHIO->mWallHang.mWallMove.m.mMinAnmSpeed,
+        dusk::getSettings().game.fastClimbing ? 2.0f : mpHIO->mWallHang.mWallMove.m.mMaxAnmSpeed
+    );
+    #else
     return getAnmSpeedStickRate(mpHIO->mWallHang.mWallMove.m.mMinAnmSpeed,
                                 mpHIO->mWallHang.mWallMove.m.mMaxAnmSpeed);
+    #endif
 }
 
 int daAlink_c::getHangDirectionFromAngle() {
@@ -278,7 +285,11 @@ int daAlink_c::procHangStartInit() {
     offNoResetFlg2(FLG2_UNK_2000);
 
     if (checkHangFootWall()) {
+        #if TARGET_PC
+        if (!is_prev_hangReady && cM_rnd() < 0.7f && !dusk::getSettings().game.noMissClimbing) {
+        #else
         if (!is_prev_hangReady && cM_rnd() < 0.7f) {
+        #endif
             setSingleAnimeParam(ANM_CLIMB_HANG_MISS, &mpHIO->mLadder.m.mWallAttachMissAnm);
             field_0x3478 = mpHIO->mLadder.m.mWallAttachMissAnm.mCancelFrame;
             voiceStart(Z2SE_AL_V_FOOT_MISS);
@@ -1209,7 +1220,12 @@ void daAlink_c::setLadderPos(int param_0) {
 
 f32 daAlink_c::getLadderMoveAnmSpeed() {
     return getAnmSpeedStickRate(mpHIO->mLadder.m.mMoveMinASpeed,
-                                mpHIO->mLadder.m.mMoveMaxSpeed);
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 1.575f : mpHIO->mLadder.m.mMoveMaxSpeed
+        #else
+        mpHIO->mLadder.m.mMoveMaxSpeed
+        #endif
+    );
 }
 
 int daAlink_c::changeLadderMoveProc(int param_0) {
@@ -1304,8 +1320,14 @@ int daAlink_c::procLadderUpStartInit() {
     mNormalSpeed = 0.0f;
     speedF = 0.0f;
 
-    setSingleAnimeBaseSpeed(ANM_LADDER_UP_START, mpHIO->mLadder.m.mClimbUpStartASpeed,
-                            mpHIO->mLadder.m.mClimbUpStartInterp);
+    setSingleAnimeBaseSpeed(ANM_LADDER_UP_START,
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 1.8f : mpHIO->mLadder.m.mClimbUpStartASpeed,
+        #else
+        mpHIO->mLadder.m.mClimbUpStartASpeed,
+        #endif
+        mpHIO->mLadder.m.mClimbUpStartInterp);
+
     field_0x2f99 = 0x10;
     field_0x3588 = l_waitBaseAnime;
     dComIfGp_setPlayerStatus0(0, 0x2000000);
@@ -1354,8 +1376,14 @@ int daAlink_c::procLadderUpEndInit(BOOL param_0) {
         anm_id = ANM_LADDER_UP_END_RIGHT;
     }
 
-    setSingleAnimeBaseSpeed(anm_id, mpHIO->mLadder.m.mClimbUpEndASpeed,
-                            mpHIO->mLadder.m.mClimbUpEndInterp);
+    setSingleAnimeBaseSpeed(anm_id,
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 1.765f : mpHIO->mLadder.m.mClimbUpEndASpeed,
+        #else
+        mpHIO->mLadder.m.mClimbUpEndASpeed,
+        #endif
+        mpHIO->mLadder.m.mClimbUpEndInterp);
+
     field_0x2f99 = 14;
     setSpecialGravity(0.0f, maxFallSpeed, 0);
 
@@ -1413,8 +1441,14 @@ int daAlink_c::procLadderDownStartInit() {
     shape_angle.y = field_0x306e + 0x8000;
     current.angle.y = field_0x306e;
 
-    setSingleAnimeBaseSpeed(ANM_LADDER_DOWN_START, mpHIO->mLadder.m.mClimbDownStartASpeed,
-                            mpHIO->mLadder.m.mClimbDownStartInterp);
+    setSingleAnimeBaseSpeed(ANM_LADDER_DOWN_START,
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 1.8f : mpHIO->mLadder.m.mClimbDownStartASpeed,
+        #else
+        mpHIO->mLadder.m.mClimbDownStartASpeed,
+        #endif
+        mpHIO->mLadder.m.mClimbDownStartInterp);
+
     field_0x2f99 = 0x10;
     field_0x3588 = l_waitBaseAnime;
     dComIfGp_setPlayerStatus0(0, 0x2000000);
@@ -1469,8 +1503,14 @@ int daAlink_c::procLadderDownEndInit(BOOL param_0) {
         anm_id = ANM_LADDER_DOWN_END_RIGHT;
     }
 
-    setSingleAnimeBaseSpeed(anm_id, mpHIO->mLadder.m.mClimbDownEndASpeed,
-                            mpHIO->mLadder.m.mClimbDownEndInterp);
+    setSingleAnimeBaseSpeed(anm_id,
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 1.8f : mpHIO->mLadder.m.mClimbDownEndASpeed,
+        #else
+        mpHIO->mLadder.m.mClimbDownEndASpeed,
+        #endif
+        mpHIO->mLadder.m.mClimbDownEndInterp);
+
     field_0x2f99 = 14;
     setSpecialGravity(0.0f, maxFallSpeed, 0);
 
@@ -1602,12 +1642,22 @@ int daAlink_c::procLadderMove() {
 
 f32 daAlink_c::getClimbMoveUpDownAnmSpeed() {
     return getAnmSpeedStickRate(mpHIO->mLadder.m.mWallVerticalMinAnmSpeed,
-                                mpHIO->mLadder.m.mWallVerticalMaxAnmSpeed);
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 1.875f : mpHIO->mLadder.m.mWallVerticalMaxAnmSpeed
+        #else
+        mpHIO->mLadder.m.mWallVerticalMaxAnmSpeed
+        #endif
+   );
 }
 
 f32 daAlink_c::getClimbMoveSideAnmSpeed() {
     return getAnmSpeedStickRate(mpHIO->mLadder.m.mWallHorizontalMinAnmSpeed,
-                                mpHIO->mLadder.m.mWallHorizontalMaxAnmSpeed);
+        #if TARGET_PC
+        dusk::getSettings().game.fastClimbing ? 2.0f : mpHIO->mLadder.m.mWallHorizontalMaxAnmSpeed
+        #else
+        mpHIO->mLadder.m.mWallHorizontalMaxAnmSpeed
+        #endif
+    );
 }
 
 BOOL daAlink_c::checkClimbCode(cBgS_PolyInfo& i_polyinfo) {
@@ -2038,7 +2088,11 @@ int daAlink_c::procClimbUpStartInit(int param_0) {
     speed.y = 0.0f;
     mNormalSpeed = 0.0f;
 
+    #if TARGET_PC
+    if (param_0 || var_r29 || cM_rnd() < 0.3f || dusk::getSettings().game.noMissClimbing) {
+    #else
     if (param_0 || var_r29 || cM_rnd() < 0.3f) {
+    #endif
         setSingleAnimeParam(ANM_CLIMB_HANG, &mpHIO->mLadder.m.mWallAttachAnm);
         field_0x3478 = mpHIO->mLadder.m.mWallAttachAnm.mCancelFrame;
         voiceStart(Z2SE_AL_V_JUMP_HANG);
@@ -2115,7 +2169,11 @@ int daAlink_c::procClimbDownStartInit(s16 param_0) {
 
     deleteEquipItem(TRUE, FALSE);
 
+    #if TARGET_PC
+    if (cM_rnd() < 0.7f || dusk::getSettings().game.noMissClimbing) {
+    #else
     if (cM_rnd() < 0.7f) {
+    #endif
         setSingleAnimeParam(ANM_CLIMB_HANG, &mpHIO->mLadder.m.mWallAttachAnm);
         field_0x3478 = mpHIO->mLadder.m.mWallAttachAnm.mCancelFrame;
         mProcVar0.field_0x3008 = 0;

src/d/actor/d_a_alink_hvyboots.inc

@@ -348,7 +348,9 @@ int daAlink_c::procMagneBootsFly() {
      * Fixed in GCN and Wii KOR versions by adding a checkEquipHeavyBoots check
      */
     if (dComIfG_Bgsp().ChkPolySafe(mPolyInfo2)
-        #if PLATFORM_GCN || VERSION == VERSION_WII_KOR
+        #if TARGET_PC
+        && (dusk::getSettings().game.restoreWiiGlitches || checkEquipHeavyBoots())
+        #elif PLATFORM_GCN || VERSION == VERSION_WII_KOR
         && checkEquipHeavyBoots()
         #endif
         )

src/d/actor/d_a_alink_kandelaar.inc

@@ -180,7 +180,12 @@ void daAlink_c::preKandelaarDraw() {
     mat_p->setTevColor(2, &color);
 
     cXyz proj;
+
+    #if TARGET_PC
+    mDoLib_project(&mKandelaarFlamePos, &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&mKandelaarFlamePos, &proj);
+    #endif
 
     camera_process_class* camera_p = dComIfGp_getCamera(0);
     f32 trimHeight;

src/d/actor/d_a_alink_swindow.inc

@@ -40,6 +40,9 @@ void daAlink_c::setOriginalHeap(JKRExpHeap** i_ppheap, u32 i_size) {
         u32 var_r29 = 0x90;
         u32 var_r28 = 0x10;
         u32 size = ROUND(i_size, 16);
+#if TARGET_PC
+        size *= 2;
+#endif
         JKRHeap* parent = mDoExt_getGameHeap();
 
         JKRExpHeap* heap = JKRExpHeap::create(size + (var_r29 + var_r28), parent, true);

src/d/actor/d_a_alink_wolf.inc

@@ -313,7 +313,12 @@ void daAlink_c::changeLink(int param_0) {
         mpLinkHandModel =
             initModel(static_cast<J3DModelData*>(dComIfG_getObjectRes(l_mArcName, "al_hands.bmd")), 0);
 
-        if (dComIfGs_getRupee() != 0) {
+#if TARGET_PC
+        if (dComIfGs_getRupee() != 0 || dusk::getSettings().game.freeMagicArmor)
+#else
+        if (dComIfGs_getRupee() != 0)
+#endif
+        {
             setMagicArmorBrk(1);
         } else {
             setMagicArmorBrk(0);
@@ -398,7 +403,11 @@ void daAlink_c::changeLink(int param_0) {
         field_0x06ec = field_0x064C->getMaterialNodePointer(1)->getShape();
         field_0x06f0 = field_0x064C->getMaterialNodePointer(2)->getShape();
 
+#if TARGET_PC
+        if (dComIfGs_getRupee() != 0 || dusk::getSettings().game.freeMagicArmor) {
+#else
         if (dComIfGs_getRupee() != 0) {
+#endif
             var_r27 = 4;
         } else {
             var_r27 = 5;

src/d/actor/d_a_b_bq.cpp

@@ -1444,11 +1444,11 @@ static void demo_camera(b_bq_class* i_this) {
             i_this->mDemoCamEyeTarget.set(240.0f, 274.0f, 2075.0f);
 
             i_this->field_0x1288.x =
-                std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+                fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
             i_this->field_0x1288.y =
-                std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+                fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
             i_this->field_0x1288.z =
-                std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+                fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
         }
 
         spFC.set(0.0f, 0.0f, 1700.0f);
@@ -1478,16 +1478,16 @@ static void demo_camera(b_bq_class* i_this) {
         i_this->mDemoCamCenterTarget.set(76.0f, 204.0f, 1782.0f);
         i_this->mDemoCamEyeTarget.set(-41.0f, 261.0f, 2095.0f);
 
-        i_this->field_0x127c.x = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-        i_this->field_0x127c.y = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-        i_this->field_0x127c.z = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+        i_this->field_0x127c.x = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+        i_this->field_0x127c.y = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+        i_this->field_0x127c.z = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
         i_this->field_0x1288.x =
-            std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+            fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
         i_this->field_0x1288.y =
-            std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+            fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
         i_this->field_0x1288.z =
-            std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+            fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
 
         i_this->field_0x129c = 0.0f;
         i_this->mDemoMode = 12;
@@ -1584,16 +1584,16 @@ static void demo_camera(b_bq_class* i_this) {
         i_this->mDemoCamCenterTarget.set(0.0f, 278.0f, 1252.0f);
         i_this->mDemoCamEyeTarget.set(0.0f, 86.0f, 2167.0f);
 
-        i_this->field_0x127c.x = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-        i_this->field_0x127c.y = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-        i_this->field_0x127c.z = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+        i_this->field_0x127c.x = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+        i_this->field_0x127c.y = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+        i_this->field_0x127c.z = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
         i_this->field_0x1288.x =
-            std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+            fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
         i_this->field_0x1288.y =
-            std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+            fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
         i_this->field_0x1288.z =
-            std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+            fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
 
         i_this->field_0x129c = 0.0f;
         i_this->mDemoMode = 14;
@@ -1741,16 +1741,16 @@ static void demo_camera(b_bq_class* i_this) {
         i_this->mDemoCamCenterTarget.set(-2243.0f, 1340.0f, 977.0f);
         i_this->mDemoCamEyeTarget.set(-1226.0f, 980.0f, 1350.0f);
 
-        i_this->field_0x127c.x = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-        i_this->field_0x127c.y = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-        i_this->field_0x127c.z = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+        i_this->field_0x127c.x = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+        i_this->field_0x127c.y = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+        i_this->field_0x127c.z = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
         i_this->field_0x1288.x =
-            std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+            fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
         i_this->field_0x1288.y =
-            std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+            fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
         i_this->field_0x1288.z =
-            std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+            fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
 
         i_this->field_0x129c = 0.0f;
         i_this->mDemoMode = 34;
@@ -1814,9 +1814,9 @@ static void demo_camera(b_bq_class* i_this) {
         i_this->mDemoCamEye.set(95.0f, 50.0f, 2800.0f);
         i_this->mDemoCamEyeTarget.set(72.0f, 52.0f, 2153.0f);
 
-        i_this->field_0x127c.x = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-        i_this->field_0x127c.y = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-        i_this->field_0x127c.z = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+        i_this->field_0x127c.x = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+        i_this->field_0x127c.y = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+        i_this->field_0x127c.z = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
         i_this->field_0x1288.set(0.0f, 0.0f, 0.0f);
         i_this->field_0x129c = 0.0f;
@@ -1973,18 +1973,18 @@ static void demo_camera(b_bq_class* i_this) {
             i_this->mDemoCamEyeTarget.set(1214.0f, 350.0f, 2696.0f);
 
             i_this->field_0x127c.x =
-                std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+                fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
             i_this->field_0x127c.y =
-                std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+                fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
             i_this->field_0x127c.z =
-                std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+                fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
             i_this->field_0x1288.x =
-                std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+                fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
             i_this->field_0x1288.y =
-                std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+                fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
             i_this->field_0x1288.z =
-                std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+                fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
 
             i_this->field_0x129c = 0.0f;
         } else if (i_this->mDemoModeTimer < 140) {
@@ -1993,18 +1993,18 @@ static void demo_camera(b_bq_class* i_this) {
                 i_this->mDemoCamEyeTarget.set(23.0f, 108.0f, 2155.0f);
 
                 i_this->field_0x127c.x =
-                    std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+                    fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
                 i_this->field_0x127c.y =
-                    std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+                    fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
                 i_this->field_0x127c.z =
-                    std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+                    fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
                 i_this->field_0x1288.x =
-                    std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+                    fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
                 i_this->field_0x1288.y =
-                    std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+                    fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
                 i_this->field_0x1288.z =
-                    std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+                    fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
             }
 
             cam_3d_morf(i_this, 0.1f);
@@ -2042,18 +2042,18 @@ static void demo_camera(b_bq_class* i_this) {
                 i_this->mDemoCamEyeTarget.set(953.0f, 997.0f, -36.0f);
 
                 i_this->field_0x127c.x =
-                    std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+                    fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
                 i_this->field_0x127c.y =
-                    std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+                    fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
                 i_this->field_0x127c.z =
-                    std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+                    fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
 
                 i_this->field_0x1288.x =
-                    std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+                    fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
                 i_this->field_0x1288.y =
-                    std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+                    fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
                 i_this->field_0x1288.z =
-                    std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+                    fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
 
                 cXyz pos(0.0f, 0.0f, 0.0f);
                 for (int i = 0; i < 5; i++) {

src/d/actor/d_a_b_ob.cpp

@@ -2462,12 +2462,12 @@ static void demo_camera(b_ob_class* i_this) {
                 i_this->mDemoCamCenterTarget.set(80.0f, -24093.0f, 160.0f);
                 i_this->mDemoCamEyeTarget.set(-447.0f, -22850.0f, -718.0f);
 
-                i_this->field_0x5cb4 = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-                i_this->field_0x5cb8 = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-                i_this->field_0x5cbc = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
-                i_this->field_0x5cc0 = std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
-                i_this->field_0x5cc4 = std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
-                i_this->field_0x5cc8 = std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+                i_this->field_0x5cb4 = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+                i_this->field_0x5cb8 = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+                i_this->field_0x5cbc = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+                i_this->field_0x5cc0 = fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+                i_this->field_0x5cc4 = fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+                i_this->field_0x5cc8 = fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
                 i_this->field_0x5cd0 = 0.0f;
 
                 daPy_getPlayerActorClass()->changeDemoMode(0x17, 0, 0, 0);
@@ -2590,12 +2590,12 @@ static void demo_camera(b_ob_class* i_this) {
         i_this->mDemoCamCenterTarget.set(-6378.0f, -21886.0f, 7150.0f);
         i_this->mDemoCamEyeTarget.set(-6961.0f, -21727.0f, 7278.0f);
 
-        i_this->field_0x5cb4 = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-        i_this->field_0x5cb8 = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-        i_this->field_0x5cbc = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
-        i_this->field_0x5cc0 = std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
-        i_this->field_0x5cc4 = std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
-        i_this->field_0x5cc8 = std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+        i_this->field_0x5cb4 = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+        i_this->field_0x5cb8 = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+        i_this->field_0x5cbc = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+        i_this->field_0x5cc0 = fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+        i_this->field_0x5cc4 = fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+        i_this->field_0x5cc8 = fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
         i_this->field_0x5cd0 = 0.0f;
 
         i_this->mDemoAction = 46;
@@ -2656,12 +2656,12 @@ static void demo_camera(b_ob_class* i_this) {
             i_this->mDemoCamCenterTarget.set(-2933.0f, -22626.0f, 6829.0f);
             i_this->mDemoCamEyeTarget.set(-3295.0f, -22459.0f, 7307.0f);
 
-            i_this->field_0x5cb4 = std::fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
-            i_this->field_0x5cb8 = std::fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
-            i_this->field_0x5cbc = std::fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
-            i_this->field_0x5cc0 = std::fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
-            i_this->field_0x5cc4 = std::fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
-            i_this->field_0x5cc8 = std::fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
+            i_this->field_0x5cb4 = fabsf(i_this->mDemoCamEyeTarget.x - i_this->mDemoCamEye.x);
+            i_this->field_0x5cb8 = fabsf(i_this->mDemoCamEyeTarget.y - i_this->mDemoCamEye.y);
+            i_this->field_0x5cbc = fabsf(i_this->mDemoCamEyeTarget.z - i_this->mDemoCamEye.z);
+            i_this->field_0x5cc0 = fabsf(i_this->mDemoCamCenterTarget.x - i_this->mDemoCamCenter.x);
+            i_this->field_0x5cc4 = fabsf(i_this->mDemoCamCenterTarget.y - i_this->mDemoCamCenter.y);
+            i_this->field_0x5cc8 = fabsf(i_this->mDemoCamCenterTarget.z - i_this->mDemoCamCenter.z);
             i_this->field_0x5cd0 = 0.0f;
 
             i_this->mDemoAction = 48;

src/d/actor/d_a_balloon_2D.cpp

@@ -304,7 +304,11 @@ void daBalloon2D_c::addScoreCount(cXyz* param_1, u32 param_2, u8 param_3) {
         field_0x5f8[current].field_0xf = field_0x5f8[prev].field_0xf;
     }
     cXyz acStack_2c;
+    #if TARGET_PC
+    mDoLib_project(param_1, &acStack_2c, { 0, 0, FB_WIDTH, FB_HEIGHT });
+    #else
     mDoLib_project(param_1, &acStack_2c);
+    #endif
     field_0x5f8[0].field_0x0.set(acStack_2c);
     field_0x5f8[0].field_0xc = param_2;
     field_0x5f8[0].field_0xe = 60;

src/d/actor/d_a_bg_obj.cpp

@@ -976,7 +976,7 @@ void daBgObj_c::setSe() {
     temp++;
 
     for (; i != 0; i--) {
-        fopAcM_seStart(this, *temp, 0);
+        fopAcM_seStart(this, *(BE(u32)*)temp, 0);
         temp++;
     }
 }

src/d/actor/d_a_coach_2D.cpp

@@ -14,6 +14,8 @@
 #include "JSystem/J2DGraph/J2DAnmLoader.h"
 #include <cstring>
 
+#include "dusk/memory.h"
+
 class daCoach2D_HIO_c : public mDoHIO_entry_c {
 public:
     struct Param {
@@ -153,7 +155,7 @@ int daCoach2D_c::createHeap() {
 int daCoach2D_c::create() {
     int phase_state = dComIfG_resLoad(this, l_arcName);
     if (phase_state == cPhs_COMPLEATE_e) {
-        if (!fopAcM_entrySolidHeap(this, daCoach2D_createHeap, 0x5050)) {
+        if (!fopAcM_entrySolidHeap(this, daCoach2D_createHeap, HEAP_SIZE(0x5050, 0x6000))) {
             return cPhs_ERROR_e;
         }
 

src/d/actor/d_a_demo00.cpp

@@ -1096,8 +1096,14 @@ inline int daDemo00_c::execute() {
                         case 2: {
                             u16 sp0A = sp0E & 0x3FFF;
                             if ((sp0E & 0xC000) == 0) {
+#if !MOVIE_SUPPORT
+                                // If movie support isn't available, automatically reset.
+                                // TPHD-esque. Maybe not the best solution, but it works.
+                                dComIfGp_event_reset();
+#else
                                 fopAcM_create(fpcNm_MOVIE_PLAYER_e, sp0A, NULL, fopAcM_GetRoomNo(this), NULL, NULL, 0xFF);
                                 mDoGph_gInf_c::fadeOut(1.0f);
+#endif
                             } else {
                                 switch (sp0A) {
                                     case 0:
@@ -1652,7 +1658,12 @@ int daDemo00_c::draw() {
             MTXCopy(mModel.field_0x5d4->getAnmMtx(0), mDoMtx_stack_c::get());
             spb0.set(0.0f, 0.0f, 0.0f);
             mDoMtx_stack_c::multVec(&spb0, &sp98);
+
+            #if TARGET_PC
+            mDoLib_project(&sp98, &spa4, {0, 0, FB_WIDTH, FB_HEIGHT});
+            #else
             mDoLib_project(&sp98, &spa4);
+            #endif
 
             if (spa4.x >= -700.0f && spa4.x < 1600.0f && spa4.y >= -200.0f && spa4.y < 600.0f) {
                 if (mModel.mID.field_0x18 == 0 || mModel.mID.field_0x18 == 1) {

src/d/actor/d_a_e_fk.cpp

@@ -429,7 +429,13 @@ void daE_FK_c::DamageAction() {
 
 bool daE_FK_c::checkViewArea() {
     Vec proj;
+
+    #if TARGET_PC
+    mDoLib_project(&current.pos, &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&current.pos, &proj);
+    #endif
+
     return (proj.x >= 0.0f && proj.x <= FB_WIDTH) && (proj.y >= 0.0f && proj.y <= FB_HEIGHT);
 }
 

src/d/actor/d_a_e_fs.cpp

@@ -463,7 +463,13 @@ static void damage_check(e_fs_class* i_this) {
 
 static bool checkViewArea(cXyz* i_pos) {
     Vec proj;
+
+    #if TARGET_PC
+    mDoLib_project(i_pos, &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(i_pos, &proj);
+    #endif
+
     bool ret = false;
     if (proj.x >= 0.0f && proj.x <= FB_WIDTH && proj.y >= 0.0f && proj.y <= FB_HEIGHT) {
         ret = true;

src/d/actor/d_a_e_oc.cpp

@@ -189,8 +189,8 @@ int daE_OC_c::draw() {
     return 1;
 }
 
-static void daE_OC_Draw(daE_OC_c* i_this) {
-    i_this->draw();
+static int daE_OC_Draw(daE_OC_c* i_this) {
+    return i_this->draw();
 }
 
 daE_OC_c* E_OC_n::m_battle_oc;
@@ -2639,12 +2639,12 @@ int daE_OC_c::execute() {
     return 1;
 }
 
-static void daE_OC_Execute(daE_OC_c* i_this) {
-    i_this->execute();
+static int daE_OC_Execute(daE_OC_c* i_this) {
+    return i_this->execute();
 }
 
-static BOOL daE_OC_IsDelete(daE_OC_c* param_0) {
-    return TRUE;
+static int daE_OC_IsDelete(daE_OC_c* param_0) {
+    return 1;
 }
 
 int daE_OC_c::_delete() {
@@ -2662,9 +2662,9 @@ int daE_OC_c::_delete() {
     return 1;
 }
 
-static void daE_OC_Delete(daE_OC_c* i_this) {
+static int daE_OC_Delete(daE_OC_c* i_this) {
     fopAcM_RegisterDeleteID(i_this, "E_OC");
-    i_this->_delete();
+    return i_this->_delete();
 }
 
 int daE_OC_c::CreateHeap() {
@@ -2833,8 +2833,8 @@ cPhs_Step daE_OC_c::create() {
     return phase;
 }
 
-static void daE_OC_Create(daE_OC_c* i_this) {
-    i_this->create();
+static int daE_OC_Create(daE_OC_c* i_this) {
+    return i_this->create();
 }
 
 static actor_method_class l_daE_OC_Method = {

src/d/actor/d_a_e_ph.cpp

@@ -1154,6 +1154,18 @@ int daE_PH_c::create() {
 
     int phase_state = dComIfG_resLoad(&mPhase, "E_PH");
     if (phase_state == cPhs_COMPLEATE_e) {
+
+#if TARGET_PC
+        // Due to our loads being so much faster, peahats can initialize *before* the camera.
+        // This breaks the peahat used for camera focus during transition to phase 2 of Argorok.
+        // as it caches incorrect camera parameters in its init.
+        if (auto cam = dComIfGp_getCamera(0)) {
+            if (cam->phase_request.mpHandlerTable != nullptr) {
+                return cPhs_INIT_e;
+            }
+        }
+#endif
+
         mAction = fopAcM_GetParam(this) & 0xF;
 
         if (dComIfGs_isZoneSwitch(2, fopAcM_GetRoomNo(this)) && mAction == 4) {

src/d/actor/d_a_e_sm.cpp

@@ -1362,7 +1362,13 @@ void daE_SM_c::E_SM_C_Hook() {
 
 bool daE_SM_c::CheckViewArea() {
     Vec vec;
+
+    #if TARGET_PC
+    mDoLib_project(&current.pos, &vec, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&current.pos, &vec);
+    #endif
+
     bool rv = false;
 
     if (vec.x >= 0.0f && vec.x <= FB_WIDTH && vec.y >= 0.0f && vec.y <= FB_HEIGHT) {

src/d/actor/d_a_e_ws.cpp

@@ -10,6 +10,10 @@
 #include <cmath>
 #include "f_op/f_op_actor_enemy.h"
 
+#define PLAYER_NOT_FOUND  0
+#define PLAYER_TARGET   1
+#define PLAYER_NEAR     2
+
 class daE_WS_HIO_c : public JORReflexible {
 public:
     daE_WS_HIO_c();
@@ -28,6 +32,7 @@ public:
     /* 0x24 */ u8 debug_ON;
 };
 
+
 namespace {
 static dCcD_SrcSph cc_ws_src = {
     {
@@ -66,13 +71,27 @@ daE_WS_HIO_c::daE_WS_HIO_c() {
     attack_speed = 10.0f;
 }
 
+#if DEBUG
+void daE_WS_HIO_c::genMessage(JORMContext* ctx) {
+    ctx->genLabel("スタルウォーーーーーーーール", 0x80000001);
+    ctx->genSlider("基本サイズ", &base_size, 0.0f, 5.0f);
+    ctx->genSlider("サーチ角度", &search_angle, 0.0f, 30000.0f);
+    ctx->genSlider("攻撃速度", &attack_speed, 0.0f, 100.0f);
+    ctx->genSlider("移動範囲", &move_range, 0.0f, 1000.0f);
+    ctx->genSlider("サーチ範囲", &search_range, 0.0f, 1000.0f);
+    ctx->genSlider("サーチY上下範囲", &search_y_range, 0.0f, 1000.0f);
+    ctx->genSlider("地面までの距離", &dist_to_ground, 0.0f, 1000.0f);
+    ctx->genCheckBox("デバック表示", &debug_ON, 0x1);
+}
+#endif
+
 int daE_WS_c::draw() {
-    J3DModel* model_p = mpModelMorf->getModel();
+    J3DModel* model = mAnm_p->getModel();
     g_env_light.settingTevStruct(0, &current.pos, &tevStr);
-    g_env_light.setLightTevColorType_MAJI(model_p, &tevStr);
+    g_env_light.setLightTevColorType_MAJI(model, &tevStr);
 
     if (mDownColor) {
-        J3DModelData* modelData_p = model_p->getModelData();
+        J3DModelData* modelData_p = model->getModelData();
         for (u16 i = 0; i < modelData_p->getMaterialNum(); i++) {
             J3DMaterial* material_p = modelData_p->getMaterialNodePointer(i);
             material_p->getTevColor(0)->r = mDownColor;
@@ -81,48 +100,48 @@ int daE_WS_c::draw() {
         }
     }
 
-    mpModelMorf->entryDL();
+    mAnm_p->entryDL();
 
     cXyz sp8;
     sp8.set(current.pos.x, 100.0f + current.pos.y, current.pos.z);
-    mShadowId = dComIfGd_setShadow(mShadowId, 1, model_p, &sp8, 400.0f, 0.0f, current.pos.y, mAcch.GetGroundH(), mAcch.m_gnd, &tevStr, 0, 1.0f, dDlst_shadowControl_c::getSimpleTex());
+    mShadowId = dComIfGd_setShadow(mShadowId, 1, model, &sp8, 400.0f, 0.0f, current.pos.y, mAcch.GetGroundH(), mAcch.m_gnd, &tevStr, 0, 1.0f, dDlst_shadowControl_c::getSimpleTex());
     return 1;
 }
 
-static int daE_WS_Draw(daE_WS_c* a_this) {
-    return a_this->draw();
+static int daE_WS_Draw(daE_WS_c* i_this) {
+    return i_this->draw();
 }
 
 void daE_WS_c::setBck(int i_anm, u8 i_mode, f32 i_morf, f32 i_speed) {
-    mpModelMorf->setAnm((J3DAnmTransform*)dComIfG_getObjectRes("E_WS", i_anm), i_mode, i_morf, i_speed, 0.0f, -1.0f);
+    mAnm_p->setAnm((J3DAnmTransform*)dComIfG_getObjectRes("E_WS", i_anm), i_mode, i_morf, i_speed, 0.0f, -1.0f);
 }
 
 void daE_WS_c::setFootSound() {
-    if (mpModelMorf->getAnm() == dComIfG_getObjectRes("E_WS", 7)) {
-        if (mpModelMorf->checkFrame(0.0f)  ||
-            mpModelMorf->checkFrame(4.5f)  ||
-            mpModelMorf->checkFrame(7.5f)  ||
-            mpModelMorf->checkFrame(9.0f)  ||
-            mpModelMorf->checkFrame(13.5f) ||
-            mpModelMorf->checkFrame(16.0f) ||
-            mpModelMorf->checkFrame(19.0f) ||
-            mpModelMorf->checkFrame(23.5f) ||
-            mpModelMorf->checkFrame(25.0f) ||
-            mpModelMorf->checkFrame(28.0f) ||
-            mpModelMorf->checkFrame(32.5f) ||
-            mpModelMorf->checkFrame(36.0f) ||
-            mpModelMorf->checkFrame(39.5f))
+    if (mAnm_p->getAnm() == dComIfG_getObjectRes("E_WS", 7)) {
+        if (mAnm_p->checkFrame(0.0f)  ||
+            mAnm_p->checkFrame(4.5f)  ||
+            mAnm_p->checkFrame(7.5f)  ||
+            mAnm_p->checkFrame(9.0f)  ||
+            mAnm_p->checkFrame(13.5f) ||
+            mAnm_p->checkFrame(16.0f) ||
+            mAnm_p->checkFrame(19.0f) ||
+            mAnm_p->checkFrame(23.5f) ||
+            mAnm_p->checkFrame(25.0f) ||
+            mAnm_p->checkFrame(28.0f) ||
+            mAnm_p->checkFrame(32.5f) ||
+            mAnm_p->checkFrame(36.0f) ||
+            mAnm_p->checkFrame(39.5f))
         {
             mSound.startCreatureSound(Z2SE_EN_WS_FOOTNOTE, 0, -1);
         }
-    } else if (mpModelMorf->getAnm() == dComIfG_getObjectRes("E_WS", 8)) {
-        if (mpModelMorf->checkFrame(0.5f)  ||
-            mpModelMorf->checkFrame(6.0f)  ||
-            mpModelMorf->checkFrame(11.0f) ||
-            mpModelMorf->checkFrame(16.0f) ||
-            mpModelMorf->checkFrame(21.0f) ||
-            mpModelMorf->checkFrame(26.5f) ||
-            mpModelMorf->checkFrame(31.0f))
+    } else if (mAnm_p->getAnm() == dComIfG_getObjectRes("E_WS", 8)) {
+        if (mAnm_p->checkFrame(0.5f)  ||
+            mAnm_p->checkFrame(6.0f)  ||
+            mAnm_p->checkFrame(11.0f) ||
+            mAnm_p->checkFrame(16.0f) ||
+            mAnm_p->checkFrame(21.0f) ||
+            mAnm_p->checkFrame(26.5f) ||
+            mAnm_p->checkFrame(31.0f))
         {
             mSound.startCreatureSound(Z2SE_EN_WS_FOOTNOTE, 0, -1);
         }
@@ -141,13 +160,13 @@ f32 daE_WS_c::calcTargetDist(cXyz i_basePos, cXyz i_targetPos) {
 }
 
 s16 daE_WS_c::calcTargetAngle(cXyz i_basePos, cXyz i_targetPos) {
-    cXyz sp1C;
-    cXyz sp10 = i_targetPos - i_basePos;
+    cXyz mae;
+    cXyz ato = i_targetPos - i_basePos;
 
-    mDoMtx_stack_c::XrotS(-field_0x668.x);
-    mDoMtx_stack_c::YrotM(-field_0x668.y);
-    mDoMtx_stack_c::multVec(&sp10, &sp1C);
-    return cM_atan2s(sp1C.x, sp1C.z);
+    mDoMtx_stack_c::XrotS(-mTargetWallAngle.x);
+    mDoMtx_stack_c::YrotM(-mTargetWallAngle.y);
+    mDoMtx_stack_c::multVec(&ato, &mae);
+    return cM_atan2s(mae.x, mae.z);
 }
 
 static u8 hio_set;
@@ -171,13 +190,13 @@ int daE_WS_c::checkPlayerPos() {
         dComIfGp_checkPlayerStatus1(0, 0x2000000) ||
         dComIfGp_checkPlayerStatus1(0, 0x10000) ||
         calcTargetDist(current.pos, player_pos) < 150.0f) &&
-        checkInSearchRange(player_pos, field_0x65c) && checkInSearchRange(current.pos, field_0x65c))
+        checkInSearchRange(player_pos, mHomePos) && checkInSearchRange(current.pos, mHomePos))
     {
         dBgS_GndChk gndchk;
         cXyz gndpos;
 
         mDoMtx_stack_c::transS(current.pos);
-        mDoMtx_stack_c::ZXYrotM(field_0x66e);
+        mDoMtx_stack_c::ZXYrotM(mWallAngle);
         mDoMtx_stack_c::ZXYrotM(shape_angle);
         mDoMtx_stack_c::transM(0.0f, 100.0f, 0.0f);
         mDoMtx_stack_c::multVecZero(&gndpos);
@@ -187,17 +206,17 @@ int daE_WS_c::checkPlayerPos() {
         if (current.pos.y - gndpos.y > l_HIO.dist_to_ground) {
             // Return 1 if walltula is looking towards player
             if (cLib_distanceAngleS(shape_angle.y, calcTargetAngle(current.pos, player_pos)) < l_HIO.search_angle) {
-                return 1;
+                return PLAYER_TARGET;
             }
 
             // otherwise return 2 if player is near the walltula
             if (calcTargetDist(current.pos, player_pos) < 150.0f) {
-                return 2;
+                return PLAYER_NEAR;
             }
         }
     }
 
-    return 0;
+    return PLAYER_NOT_FOUND;
 }
 
 bool daE_WS_c::checkAttackEnd() {
@@ -205,17 +224,17 @@ bool daE_WS_c::checkAttackEnd() {
     mDoMtx_stack_c::copy(daPy_getLinkPlayerActorClass()->getModelJointMtx(0));
     mDoMtx_stack_c::multVecZero(&player_pos);
 
-    BOOL r30 = false;
+    BOOL checkPlayerNear = FALSE;
     if (
         daPy_getPlayerActorClass()->checkClimbMove() ||
         dComIfGp_checkPlayerStatus1(0, 0x02000000) ||
         dComIfGp_checkPlayerStatus1(0, 0x10000) ||
         calcTargetDist(current.pos, player_pos) < 200.0f
     ) {
-        r30 = true;
+        checkPlayerNear = TRUE;
     }
-    if (!r30 ||
-        !checkInSearchRange(current.pos, field_0x65c) ||
+    if (!checkPlayerNear ||
+        !checkInSearchRange(current.pos, mHomePos) ||
         checkBeforeBg(shape_angle.y)
     )
     {
@@ -228,41 +247,41 @@ bool daE_WS_c::checkAttackEnd() {
 }
 
 void daE_WS_c::executeWait() {
-    int temp_r3 = checkPlayerPos();
-    if (temp_r3 == 1) {
+    int playerCheck = checkPlayerPos();
+    if (playerCheck == PLAYER_TARGET) {
         setActionMode(ACTION_ATTACK_e);
         return;
     }
 
-    if (temp_r3 == 2 && mMode != 3 && mMode != 4) {
+    if (playerCheck == PLAYER_NEAR && mMode != 3 && mMode != 4) {
         mMode = 2;
     }
 
     switch (mMode) {
     case 0:
-        mMoveWaitTimer = 50.0f + cM_rndF(50.0f);
+        mWaitTimer = 50.0f + cM_rndF(50.0f);
         setBck(9, 2, 3.0f, 1.0f);
         mMode = 1;
         /* fallthrough */
     case 1:
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             mMode = 2;
         }
         break;
     case 2:
         speedF = 0.0f;
-        field_0x690 = 0;
-        mTargetAngle = shape_angle.y + cM_rndFX(32768.0f);
+        mIsReturnHome = 0;
+        mTargetAngle = shape_angle.y + cM_rndFX(32768.0f); // random turn up to ±180°
 
-        if (temp_r3 == 2) {
-            mTargetStep = 0x200;
+        if (playerCheck == PLAYER_NEAR) {
+            mStepAngle = 0x200;
             setBck(8, 2, 3.0f, 2.4f);
         } else {
-            if (calcTargetDist(current.pos, field_0x65c) >= l_HIO.move_range) {
-                mTargetAngle = calcTargetAngle(current.pos, field_0x65c);
-                field_0x690 = 1;
+            if (calcTargetDist(current.pos, mHomePos) >= l_HIO.move_range) {
+                mTargetAngle = calcTargetAngle(current.pos, mHomePos);
+                mIsReturnHome = 1;
             }
-            mTargetStep = 0x100;
+            mStepAngle = 0x100;
             setBck(8, 2, 3.0f, 1.2f);
         }
 
@@ -271,37 +290,37 @@ void daE_WS_c::executeWait() {
     case 3:
         setFootSound();
 
-        if (cLib_chaseAngleS(&shape_angle.y, mTargetAngle, mTargetStep)) {
+        if (cLib_chaseAngleS(&shape_angle.y, mTargetAngle, mStepAngle)) {
             mMode = 4;
-            mMoveWaitTimer = 10;
+            mWaitTimer = 10;
             setBck(9, 2, 3.0f, 1.0f);
         }
         break;
     case 4:
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             mMode = 5;
         }
         break;
     case 5:
         mMode = 6;
         speedF = 3.0f;
-        mMoveWaitTimer = 20.0f + cM_rndF(10.0f);
+        mWaitTimer = 20.0f + cM_rndF(10.0f);
         setBck(7, 2, 3.0f, 1.0f);
         /* fallthrough */
     case 6:
         setFootSound();
 
-        if (field_0x690 == 0) {
-            if (calcTargetDist(current.pos, field_0x65c) >= l_HIO.move_range) {
-                mMoveWaitTimer = 0;
+        if (mIsReturnHome == 0) {
+            if (calcTargetDist(current.pos, mHomePos) >= l_HIO.move_range) {
+                mWaitTimer = 0;
             }
         }
 
         if (checkBeforeBg(shape_angle.y)) {
-            mMoveWaitTimer = 0;
+            mWaitTimer = 0;
         }
 
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             speedF = 0.0f;
             mMode = 0;
         }
@@ -333,11 +352,11 @@ void daE_WS_c::executeAttack() {
             mMode = 2;
             setBck(10, 2, 3.0f, 1.0f);
             mSound.startCreatureVoice(Z2SE_EN_WS_V_YOKOKU, -1);
-            mMoveWaitTimer = 10;
+            mWaitTimer = 10;
         }
         break;
     case 2:
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             speedF = l_HIO.attack_speed * mBodyScale;
             setBck(7, 2, 3.0f, 3.0f);
             mMode = 3;
@@ -352,20 +371,20 @@ void daE_WS_c::executeAttack() {
         setFootSound();
         cLib_chaseAngleS(&shape_angle.y, calcTargetAngle(current.pos, player_pos), 0x400);
 
-        BOOL r28 = false;
+        BOOL checkAttackStart = FALSE;
         if (checkBeforeBg(shape_angle.y)) {
-            r28 = true;
+            checkAttackStart = TRUE;
         }
         if (mCcSph.ChkAtHit()) {
-            cCcD_Obj* r27 = mCcSph.GetAtHitObj();
-            if (fopAcM_GetName(dCc_GetAc(r27->GetAc())) == fpcNm_ALINK_e) {
-                r28 = true;
+            cCcD_Obj* hitObj = mCcSph.GetAtHitObj();
+            if (fopAcM_GetName(dCc_GetAc(hitObj->GetAc())) == fpcNm_ALINK_e) {
+                checkAttackStart = TRUE;
             }
         }
-        if (!checkInSearchRange(current.pos, field_0x65c)) {
-            r28 = true;
+        if (!checkInSearchRange(current.pos, mHomePos)) {
+            checkAttackStart = TRUE;
         }
-        if (r28) {
+        if (checkAttackStart) {
             mMode = 4;
             speedF = 0.0f;
             setBck(4, 0, 3.0f, 1.0f);
@@ -378,11 +397,11 @@ void daE_WS_c::executeAttack() {
         break;
     }
     case 4:
-        if (mpModelMorf->checkFrame(7.5f)) {
+        if (mAnm_p->checkFrame(7.5f)) {
             mSound.startCreatureVoice(Z2SE_EN_WS_V_ATTACK, -1);
         }
 
-        if (mpModelMorf->isStop()) {
+        if (mAnm_p->isStop()) {
             setActionMode(ACTION_WAIT_e);
         }
         /* fallthrough */
@@ -408,9 +427,9 @@ void daE_WS_c::executeDown() {
         mSound.startCreatureVoice(Z2SE_EN_WS_V_DAMAGE, -1);
         /* fallthrough */
     case 1:
-        if (mpModelMorf->isStop()) {
-            mAcchCir.SetWall(0.0f, 4.0f);
-            current.angle.y = field_0x668.y;
+        if (mAnm_p->isStop()) {
+            mBgc.SetWall(0.0f, 4.0f);
+            current.angle.y = mTargetWallAngle.y;
             setBck(6, 0, 3.0f, 0.0f);
             mSound.startCreatureVoice(Z2SE_EN_WS_V_DEATH, -1);
             speedF = 5.0f;
@@ -433,7 +452,7 @@ void daE_WS_c::executeDown() {
             speedF = 3.0f + cM_rndF(2.0f);
             speed.y = 12.0f;
             mMode = 3;
-            mMoveWaitTimer = 30;
+            mWaitTimer = 30;
             setBck(6, 0, 5.0f, 1.0f);
             mSound.startCreatureSound(Z2SE_CM_BODYFALL_S, 0, -1);
         }
@@ -467,8 +486,8 @@ void daE_WS_c::executeDown() {
     case 4:
         cLib_addCalc2(&mDownColor, -20.0f, 1.0f, 0.4f);
 
-        if (mpModelMorf->isStop()) {
-            mMoveWaitTimer = 15;
+        if (mAnm_p->isStop()) {
+            mWaitTimer = 15;
             mMode = 5;
             return;
         }
@@ -476,12 +495,12 @@ void daE_WS_c::executeDown() {
     case 5:
         cLib_addCalc2(&mDownColor, -20.0f, 1.0f, 0.4f);
 
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             fopAcM_delete(this);
             fopAcM_createDisappear(this, &current.pos, 7, 0, 7);
 
-            if (mSwbit != 0xFF && !dComIfGs_isSwitch(mSwbit, fopAcM_GetRoomNo(this))) {
-                dComIfGs_onSwitch(mSwbit, fopAcM_GetRoomNo(this));
+            if (bitSw != 0xFF && !dComIfGs_isSwitch(bitSw, fopAcM_GetRoomNo(this))) {
+                dComIfGs_onSwitch(bitSw, fopAcM_GetRoomNo(this));
             }
         }
         break;
@@ -497,36 +516,36 @@ void daE_WS_c::executeWindDown() {
         mCcSph.OffTgSetBit();
         mCcBokkuriSph.OffTgSetBit();
     
-        mAcchCir.SetWall(0.0f, 4.0f);
+        mBgc.SetWall(0.0f, 4.0f);
         mMode = 1;
         setBck(7, 2, 3.0f, 1.0f);
     
         mSound.startCreatureVoice(Z2SE_EN_WS_V_DAMAGE, -1);
-        mMoveWaitTimer = 5;
+        mWaitTimer = 5;
         mAcch.SetGroundUpY(20.0f);
         attention_info.flags = 0;
         speed.y = 0.0f;
         speedF = 5.0f;
-        current.angle.y = field_0x668.y;
-        mTargetStep = -0x800;
+        current.angle.y = mTargetWallAngle.y;
+        mStepAngle = -0x800;
         break;
     case 1:
-        shape_angle.y += mTargetStep;
-        cLib_chaseAngleS(&field_0x66e.y, 0, 0x400);
-        cLib_chaseAngleS(&field_0x66e.x, 0, 0x400);
+        shape_angle.y += mStepAngle;
+        cLib_chaseAngleS(&mWallAngle.y, 0, 0x400);
+        cLib_chaseAngleS(&mWallAngle.x, 0, 0x400);
         shape_angle.x += 0x800;
         shape_angle.z += 0x800;
         speed.y = 30.0f;
 
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             mMode = 2;
             gravity = -3.0f;
         }
         break;
     case 2:
-        shape_angle.y += mTargetStep;
-        cLib_chaseAngleS(&field_0x66e.y, 0, 0x400);
-        cLib_chaseAngleS(&field_0x66e.x, 0, 0x400);
+        shape_angle.y += mStepAngle;
+        cLib_chaseAngleS(&mWallAngle.y, 0, 0x400);
+        cLib_chaseAngleS(&mWallAngle.x, 0, 0x400);
         cLib_chaseAngleS(&shape_angle.x, -0x8000, 0x400);
         cLib_chaseAngleS(&shape_angle.z, 0, 0x400);
 
@@ -534,15 +553,15 @@ void daE_WS_c::executeWindDown() {
             speedF = 3.0f + cM_rndF(2.0f);
             speed.y = 12.0f;
             mMode = 3;
-            mMoveWaitTimer = 30;
+            mWaitTimer = 30;
             setBck(6, 0, 5.0f, 1.0f);
             mSound.startCreatureVoice(Z2SE_EN_WS_V_DEATH, -1);
             mSound.startCreatureSound(Z2SE_CM_BODYFALL_S, 0, -1);
         }
         break;
     case 3:
-        shape_angle.y += mTargetStep;
-        cLib_chaseAngleS(&mTargetStep, 0, 0x80);
+        shape_angle.y += mStepAngle;
+        cLib_chaseAngleS(&mStepAngle, 0, 0x80);
         cLib_chaseAngleS(&shape_angle.x, -0x8000, 0x400);
         cLib_chaseAngleS(&shape_angle.z, 0, 0x400);
 
@@ -556,23 +575,23 @@ void daE_WS_c::executeWindDown() {
         break;
     case 4:
         cLib_addCalc2(&mDownColor, -20.0f, 1.0f, 0.4f);
-        shape_angle.y += mTargetStep;
-        cLib_chaseAngleS(&mTargetStep, 0, 0x80);
-        shape_angle.y += mTargetStep;
+        shape_angle.y += mStepAngle;
+        cLib_chaseAngleS(&mStepAngle, 0, 0x80);
+        shape_angle.y += mStepAngle;
 
-        if (mpModelMorf->isStop()) {
-            mMoveWaitTimer = 15;
+        if (mAnm_p->isStop()) {
+            mWaitTimer = 15;
             mMode = 5;
         }
         break;
     case 5:
         cLib_addCalc2(&mDownColor, -20.0f, 1.0f, 0.4f);
-        if (mMoveWaitTimer == 0) {
+        if (mWaitTimer == 0) {
             fopAcM_delete(this);
             fopAcM_createDisappear(this, &current.pos, 7, 0, 7);
 
-            if (mSwbit != 0xFF && !dComIfGs_isSwitch(mSwbit, fopAcM_GetRoomNo(this))) {
-                dComIfGs_onSwitch(mSwbit, fopAcM_GetRoomNo(this));
+            if (bitSw != 0xFF && !dComIfGs_isSwitch(bitSw, fopAcM_GetRoomNo(this))) {
+                dComIfGs_onSwitch(bitSw, fopAcM_GetRoomNo(this));
             }
         }
         break;
@@ -653,47 +672,47 @@ void daE_WS_c::action() {
     mSound.setLinkSearch(field_0x566);
 
     if (mAction != ACTION_DOWN_e && mAction != ACTION_WIND_DOWN_e) {
-        cXyz sp14;
-        mDoMtx_stack_c::YrotS(field_0x668.y);
-        mDoMtx_stack_c::XrotM(field_0x668.x);
+        cXyz ato;
+        mDoMtx_stack_c::YrotS(mTargetWallAngle.y);
+        mDoMtx_stack_c::XrotM(mTargetWallAngle.x);
         mDoMtx_stack_c::YrotM(current.angle.y);
 
-        cXyz sp8(0.0f, 0.0f, speedF);
-        mDoMtx_stack_c::multVec(&sp8, &sp14);
-        speed = sp14;
+        cXyz mae(0.0f, 0.0f, speedF);
+        mDoMtx_stack_c::multVec(&mae, &ato);
+        speed = ato;
         current.pos += speed;
     } else {
         fopAcM_posMoveF(this, NULL);
     }
 
     mAcch.CrrPos(dComIfG_Bgsp());
-    mpModelMorf->play(0, dComIfGp_getReverb(fopAcM_GetRoomNo(this)));
+    mAnm_p->play(0, dComIfGp_getReverb(fopAcM_GetRoomNo(this)));
 }
 
 void daE_WS_c::mtx_set() {
     mDoMtx_stack_c::transS(current.pos);
-    mDoMtx_stack_c::ZXYrotM(field_0x66e);
+    mDoMtx_stack_c::ZXYrotM(mWallAngle);
     mDoMtx_stack_c::ZXYrotM(shape_angle);
     mDoMtx_stack_c::scaleM(mBodyScale, mBodyScale, mBodyScale);
 
-    J3DModel* model_p = mpModelMorf->getModel();
+    J3DModel* model_p = mAnm_p->getModel();
     model_p->setBaseTRMtx(mDoMtx_stack_c::get());
-    mpModelMorf->modelCalc();
+    mAnm_p->modelCalc();
 }
 
 void daE_WS_c::cc_set() {
     cXyz mae;
     cXyz ato;
-    J3DModel* model_p = mpModelMorf->getModel();
+    J3DModel* model = mAnm_p->getModel();
 
-    mDoMtx_stack_c::YrotS(field_0x668.y);
-    mDoMtx_stack_c::XrotM(field_0x668.x);
+    mDoMtx_stack_c::YrotS(mTargetWallAngle.y);
+    mDoMtx_stack_c::XrotM(mTargetWallAngle.x);
     mae.set(0.0f, 15.0f + nREG_F(10), 0.0f);
     mDoMtx_stack_c::multVec(&mae, &ato);
     attention_info.position = current.pos + ato;
     attention_info.position.y += 90.0f * mBodyScale;
 
-    MTXCopy(model_p->getAnmMtx(1), mDoMtx_stack_c::get());
+    MTXCopy(model->getAnmMtx(1), mDoMtx_stack_c::get());
     mae.set(-15.0f + nREG_F(5), -10.0f + nREG_F(6), nREG_F(7));
     mDoMtx_stack_c::multVec(&mae, &eyePos);
 
@@ -707,8 +726,8 @@ void daE_WS_c::cc_set() {
 }
 
 int daE_WS_c::execute() {
-    if (mMoveWaitTimer != 0) {
-        mMoveWaitTimer--;
+    if (mWaitTimer != 0) {
+        mWaitTimer--;
     }
 
     if (mInvulnerabilityTimer != 0) {
@@ -725,8 +744,8 @@ int daE_WS_c::execute() {
     return 1;
 }
 
-static int daE_WS_Execute(daE_WS_c* a_this) {
-    return a_this->execute();
+static int daE_WS_Execute(daE_WS_c* i_this) {
+    return i_this->execute();
 }
 
 void daE_WS_c::checkInitialWall() {
@@ -739,7 +758,7 @@ void daE_WS_c::checkInitialWall() {
         linchk.Set(&current.pos, &endpos, NULL);
 
         if (dComIfG_Bgsp().LineCross(&linchk)) {
-            if (field_0x691 == 0 && dComIfG_Bgsp().GetWallCode(linchk) != 1 && dComIfG_Bgsp().GetWallCode(linchk) != 4) {
+            if (arg0 == 0 && dComIfG_Bgsp().GetWallCode(linchk) != 1 && dComIfG_Bgsp().GetWallCode(linchk) != 4) {
                 return;
             }
 
@@ -749,9 +768,9 @@ void daE_WS_c::checkInitialWall() {
             dComIfG_Bgsp().GetTriPla(linchk, &tri);
 
             cXyz* tri_np = tri.GetNP();
-            field_0x668.y = cM_atan2s(tri_np->x, tri_np->z);
-            field_0x668.x = cM_atan2s(tri_np->absXZ(), tri_np->y);
-            field_0x66e = field_0x668;
+            mTargetWallAngle.y = cM_atan2s(tri_np->x, tri_np->z);
+            mTargetWallAngle.x = cM_atan2s(tri_np->absXZ(), tri_np->y);
+            mWallAngle = mTargetWallAngle;
             return;
         }
     }
@@ -759,8 +778,8 @@ void daE_WS_c::checkInitialWall() {
 
 bool daE_WS_c::checkBeforeBg(s16 i_angle) {
     dBgS_LinChk linchk;
-    cXyz sp68;
-    cXyz sp5C;
+    cXyz mae;
+    cXyz ato;
     cXyz endpos;
     cXyz startpos;
 
@@ -768,56 +787,56 @@ bool daE_WS_c::checkBeforeBg(s16 i_angle) {
         return false;
     }
 
-    mDoMtx_stack_c::YrotS(field_0x668.y);
-    mDoMtx_stack_c::XrotM(field_0x668.x);
+    mDoMtx_stack_c::YrotS(mTargetWallAngle.y);
+    mDoMtx_stack_c::XrotM(mTargetWallAngle.x);
     mDoMtx_stack_c::YrotM(i_angle);
-    sp68.set(0.0f, 50.0f * mBodyScale, 0.0f);
-    mDoMtx_stack_c::multVec(&sp68, &startpos);
+    mae.set(0.0f, 50.0f * mBodyScale, 0.0f);
+    mDoMtx_stack_c::multVec(&mae, &startpos);
     startpos += current.pos;
     
-    mDoMtx_stack_c::YrotS(field_0x668.y);
-    mDoMtx_stack_c::XrotM(field_0x668.x);
+    mDoMtx_stack_c::YrotS(mTargetWallAngle.y);
+    mDoMtx_stack_c::XrotM(mTargetWallAngle.x);
     mDoMtx_stack_c::YrotM(i_angle);
-    sp68.set(0.0f, 0.0f, 50.0f * mBodyScale);
-    mDoMtx_stack_c::multVec(&sp68, &sp5C);
+    mae.set(0.0f, 0.0f, 50.0f * mBodyScale);
+    mDoMtx_stack_c::multVec(&mae, &ato);
 
-    sp68.set(sp5C.x, 0.0f, sp5C.z);
-    endpos = startpos + sp68;
+    mae.set(ato.x, 0.0f, ato.z);
+    endpos = startpos + mae;
 
     linchk.Set(&startpos, &endpos, NULL);
     if (dComIfG_Bgsp().LineCross(&linchk)) {
         return 1;
     }
 
-    if (sp5C.y > 0.0f) {
-        sp68.set(0.0f, 50.0f * mBodyScale, 0.0f);
+    if (ato.y > 0.0f) {
+        mae.set(0.0f, 50.0f * mBodyScale, 0.0f);
     } else {
-        sp68.set(0.0f, -l_HIO.dist_to_ground, 0.0f);
+        mae.set(0.0f, -l_HIO.dist_to_ground, 0.0f);
     }
 
-    endpos = startpos + sp68;
+    endpos = startpos + mae;
     linchk.Set(&startpos, &endpos, NULL);
     if (dComIfG_Bgsp().LineCross(&linchk)) {
         return true;
     }
 
-    mDoMtx_stack_c::YrotS(field_0x668.y);
-    mDoMtx_stack_c::XrotM(field_0x668.x);
+    mDoMtx_stack_c::YrotS(mTargetWallAngle.y);
+    mDoMtx_stack_c::XrotM(mTargetWallAngle.x);
     mDoMtx_stack_c::YrotM(i_angle);
-    sp68.set(0.0f, 50.0f * mBodyScale, 100.0f * mBodyScale);
-    mDoMtx_stack_c::multVec(&sp68, &sp5C);
-    startpos = current.pos + sp5C;
+    mae.set(0.0f, 50.0f * mBodyScale, 100.0f * mBodyScale);
+    mDoMtx_stack_c::multVec(&mae, &ato);
+    startpos = current.pos + ato;
 
     cXyz sp38(0.0f, -40.0f * mBodyScale, 100.0f * mBodyScale);
-    mDoMtx_stack_c::multVec(&sp38, &sp5C);
-    endpos = current.pos + sp5C;
+    mDoMtx_stack_c::multVec(&sp38, &ato);
+    endpos = current.pos + ato;
 
     linchk.Set(&startpos, &endpos, NULL);
     if (!dComIfG_Bgsp().LineCross(&linchk)) {
         return true;
     }
 
-    if (field_0x691 == 0 && dComIfG_Bgsp().GetWallCode(linchk) != 1 && dComIfG_Bgsp().GetWallCode(linchk) != 4) {
+    if (arg0 == 0 && dComIfG_Bgsp().GetWallCode(linchk) != 1 && dComIfG_Bgsp().GetWallCode(linchk) != 4) {
         return true;
     }
 
@@ -825,7 +844,7 @@ bool daE_WS_c::checkBeforeBg(s16 i_angle) {
     dComIfG_Bgsp().GetTriPla(linchk, &tri);
     
     cXyz* tri_np = tri.GetNP();
-    cLib_chaseAngleS(&field_0x66e.y, cM_atan2s(tri_np->x, tri_np->z), 0x100);
+    cLib_chaseAngleS(&mWallAngle.y, cM_atan2s(tri_np->x, tri_np->z), 0x100);
     checkWall();
     return false;
 }
@@ -834,7 +853,7 @@ bool daE_WS_c::checkWall() {
     cXyz startpos;
     cXyz endpos;
     mDoMtx_stack_c::transS(current.pos);
-    mDoMtx_stack_c::ZXYrotM(field_0x66e);
+    mDoMtx_stack_c::ZXYrotM(mWallAngle);
     mDoMtx_stack_c::ZXYrotM(shape_angle);
 
     mDoMtx_stack_c::transM(0.0f, 100.0f, 0.0f);
@@ -846,7 +865,7 @@ bool daE_WS_c::checkWall() {
     dBgS_LinChk linchk;
     linchk.Set(&startpos, &endpos, NULL);
     if (dComIfG_Bgsp().LineCross(&linchk)) {
-        if (field_0x691 == 0 && dComIfG_Bgsp().GetWallCode(linchk) != 1 && dComIfG_Bgsp().GetWallCode(linchk) != 4) {
+        if (arg0 == 0 && dComIfG_Bgsp().GetWallCode(linchk) != 1 && dComIfG_Bgsp().GetWallCode(linchk) != 4) {
             return false;
         }
 
@@ -856,8 +875,8 @@ bool daE_WS_c::checkWall() {
         dComIfG_Bgsp().GetTriPla(linchk, &tri);
 
         cXyz* tri_np = tri.GetNP();
-        field_0x668.y = cM_atan2s(tri_np->x, tri_np->z);
-        field_0x668.x = cM_atan2s(tri_np->absXZ(), tri_np->y);
+        mTargetWallAngle.y = cM_atan2s(tri_np->x, tri_np->z);
+        mTargetWallAngle.x = cM_atan2s(tri_np->absXZ(), tri_np->y);
         return true;
     }
 
@@ -871,8 +890,8 @@ static int daE_WS_IsDelete(daE_WS_c* a_this) {
 int daE_WS_c::_delete() {
     dComIfG_resDelete(&mPhase, "E_WS");
 
-    if (mHIOInit) {
-        hio_set = false;
+    if (mHioSet) {
+        hio_set = FALSE;
         mDoHIO_DELETE_CHILD(l_HIO.id);
     }
 
@@ -883,24 +902,25 @@ int daE_WS_c::_delete() {
     return 1;
 }
 
-static int daE_WS_Delete(daE_WS_c* a_this) {
-    return a_this->_delete();
+static int daE_WS_Delete(daE_WS_c* i_this) {
+    fopAcM_RegisterDeleteID(i_this, "E_WS");
+    return i_this->_delete();
 }
 
 int daE_WS_c::CreateHeap() {
     J3DModelData* modelData = (J3DModelData*)dComIfG_getObjectRes("E_WS", 0xD);
     JUT_ASSERT(1401, modelData != NULL);
 
-    mpModelMorf = JKR_NEW mDoExt_McaMorfSO(modelData, NULL, NULL, (J3DAnmTransform*)dComIfG_getObjectRes("E_WS", 7), 0, 1.0f, 0, -1, &mSound, 0x80000, 0x11000084);
-    if (mpModelMorf == NULL || mpModelMorf->getModel() == NULL) {
+    mAnm_p = JKR_NEW mDoExt_McaMorfSO(modelData, NULL, NULL, (J3DAnmTransform*)dComIfG_getObjectRes("E_WS", 7), 0, 1.0f, 0, -1, &mSound, 0x80000, 0x11000084);
+    if (mAnm_p == NULL || mAnm_p->getModel() == NULL) {
         return 0;
     }
 
     return 1;
 }
 
-static int useHeapInit(fopAc_ac_c* i_this) {
-    return ((daE_WS_c*)i_this)->CreateHeap();
+static int useHeapInit(fopAc_ac_c* actor) {
+    return ((daE_WS_c*)actor)->CreateHeap();
 }
 
 int daE_WS_c::create() {
@@ -910,8 +930,8 @@ int daE_WS_c::create() {
     if (phase_state == cPhs_COMPLEATE_e) {
         OS_REPORT("E_WS PARAM %x\n", fopAcM_GetParam(this));
     
-        mSwbit = (fopAcM_GetParam(this) & 0xFF00) >> 8;
-        if (mSwbit != 0xFF && dComIfGs_isSwitch(mSwbit, fopAcM_GetRoomNo(this))) {
+        bitSw = (fopAcM_GetParam(this) & 0xFF00) >> 8;
+        if (bitSw != 0xFF && dComIfGs_isSwitch(bitSw, fopAcM_GetRoomNo(this))) {
             OS_REPORT("E_WS やられ後なので再セットしません\n");
             return cPhs_ERROR_e;
         }
@@ -922,13 +942,13 @@ int daE_WS_c::create() {
     
         if (!hio_set) {
             hio_set = true;
-            mHIOInit = true;
+            mHioSet = true;
             l_HIO.id = mDoHIO_CREATE_CHILD("スタルウォール", &l_HIO);
         }
     
-        field_0x691 = fopAcM_GetParam(this);
-        if (field_0x691 == 0xFF) {
-            field_0x691 = 0;
+        arg0 = fopAcM_GetParam(this);
+        if (arg0 == 0xFF) {
+            arg0 = 0;
         }
     
         if (((fopAcM_GetParam(this) & 0xFF0000) >> 0x10) == 1) {
@@ -938,12 +958,12 @@ int daE_WS_c::create() {
         }
     
         attention_info.flags = fopAc_AttnFlag_BATTLE_e;
-        fopAcM_SetMtx(this, mpModelMorf->getModel()->getBaseTRMtx());
+        fopAcM_SetMtx(this, mAnm_p->getModel()->getBaseTRMtx());
         fopAcM_SetMin(this, -200.0f, -200.0f, -200.0f);
         fopAcM_SetMax(this, 200.0f, 200.0f, 200.0f);
     
-        mAcch.Set(fopAcM_GetPosition_p(this), fopAcM_GetOldPosition_p(this), this, 1, &mAcchCir, fopAcM_GetSpeed_p(this), NULL, NULL);
-        mAcchCir.SetWall(0.0f, 0.0f);
+        mAcch.Set(fopAcM_GetPosition_p(this), fopAcM_GetOldPosition_p(this), this, 1, &mBgc, fopAcM_GetSpeed_p(this), NULL, NULL);
+        mBgc.SetWall(0.0f, 0.0f);
     
         health = 10;
         field_0x560 = 10;
@@ -963,7 +983,7 @@ int daE_WS_c::create() {
         setActionMode(ACTION_WAIT_e);
         checkInitialWall();
 
-        field_0x65c = current.pos;
+        mHomePos = current.pos;
         speed.y = 0.0f;
         gravity = 0.0f;
         mtx_set();
@@ -972,8 +992,8 @@ int daE_WS_c::create() {
     return phase_state;
 }
 
-static int daE_WS_Create(daE_WS_c* a_this) {
-    return a_this->create();
+static int daE_WS_Create(daE_WS_c* i_this) {
+    return i_this->create();
 }
 
 static actor_method_class l_daE_WS_Method = {

src/d/actor/d_a_e_ym.cpp

@@ -16,6 +16,8 @@
 #include "f_op/f_op_camera_mng.h"
 #include <cstring>
 
+#include "dusk/settings.h"
+
 class daE_YM_HIO_c: public JORReflexible {
 public:
     daE_YM_HIO_c();
@@ -1066,7 +1068,11 @@ void daE_YM_c::executeDown() {
             }
             if (mAcch.ChkGroundHit()) {
                 if (mFlyType != 1) {
+                    #if TARGET_PC
+                    bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 2.0f : 1.0f);
+                    #else
                     bckSet(6, 0, 0.0f, 1.0f);
+                    #endif
                 }
                 if (mMode == 1) {
                     mSound.startCreatureSound(Z2SE_EN_YM_LAND, 0, -1);
@@ -1086,7 +1092,11 @@ void daE_YM_c::executeDown() {
             if (current.pos.y < gnd_cross) {
                 mSound.startCreatureSound(Z2SE_CM_BODYFALL_WATER_M, 0, -1);
                 mSound.startCreatureSound(Z2SE_EN_YM_MOGAKU, 0, -1);
+                #if TARGET_PC
+                bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 2.0f : 1.0f);
+                #else
                 bckSet(6, 0, 0.0f, 1.0f);
+                #endif
                 speedF = 0.0f;
                 speed.y = gravity = 0.0f;
                 current.pos.y = gnd_cross;
@@ -1102,8 +1112,13 @@ void daE_YM_c::executeDown() {
                 f32 gnd_cross_2 = dComIfG_Bgsp().GroundCross(&gnd_chk);
                 if (gnd_cross_2 == -G_CM3D_F_INF || std::abs(gnd_cross_2 - current.pos.y) > 1000.0f
                     || dComIfG_Bgsp().GetGroundCode(gnd_chk) == 4 || dComIfG_Bgsp().GetGroundCode(gnd_chk) == 10
-                    || dComIfG_Bgsp().GetGroundCode(gnd_chk) == 5) {
+                    || dComIfG_Bgsp().GetGroundCode(gnd_chk) == 5)
+            {
+                    #if TARGET_PC
+                    bckSet(6, 0, 0.0f, dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 2.0f : 1.0f);
+                    #else
                     bckSet(6, 0, 0.0f, 1.0f);
+                    #endif
                     mMode = 3;
                     speedF = 0.0f;
                     shape_angle.x = -0x8000;

src/d/actor/d_a_e_ymb.cpp

@@ -516,7 +516,7 @@ void daE_YMB_c::checkWaterPos() {
         field_0x6cc = wtr_pos;
         field_0x69c.y = wtr_pos + 1000.0f + l_HIO.fly_height_adjust;
 
-        UNUSED(std::fabsf(field_0x6cc - current.pos.y));
+        UNUSED(fabsf(field_0x6cc - current.pos.y));
         if (current.pos.y < (200.0f + field_0x6cc)) {
             if (field_0x715 == 0) {
                 setWaterEffect1();

src/d/actor/d_a_e_zs.cpp

@@ -495,8 +495,8 @@ int daE_ZS_c::CreateHeap() {
     return 1;
 }
 
-static void useHeapInit(fopAc_ac_c* i_this) {
-    static_cast<daE_ZS_c*>(i_this)->CreateHeap();
+static int useHeapInit(fopAc_ac_c* i_this) {
+    return static_cast<daE_ZS_c*>(i_this)->CreateHeap();
 }
 
 int daE_ZS_c::create() {
@@ -504,7 +504,7 @@ int daE_ZS_c::create() {
     int phase = dComIfG_resLoad(&mPhase, "E_ZS");
     if (phase == cPhs_COMPLEATE_e) {
         OS_REPORT("E_ZS PARAM %x\n", fopAcM_GetParam(this));
-        if (!fopAcM_entrySolidHeap(this, (heapCallbackFunc)useHeapInit, 0xFC0)) {
+        if (!fopAcM_entrySolidHeap(this, useHeapInit, 0xFC0)) {
             return cPhs_ERROR_e;
         }
 

src/d/actor/d_a_grass.cpp

@@ -80,12 +80,7 @@ void daGrass_c::deleteGrass() {
     }
 }
 
-dGrass_packet_c::~dGrass_packet_c() {
-#if TARGET_PC
-    GXDestroyTexObj(&mTexObj_l_M_kusa05_RGBATEX);
-    GXDestroyTexObj(&mTexObj_l_M_Hijiki00TEX);
-#endif
-}
+dGrass_packet_c::~dGrass_packet_c() {}
 
 void daGrass_c::executeGrass() {
     if (m_grass != NULL) {

src/d/actor/d_a_mant.cpp

@@ -10,11 +10,21 @@
 #include "d/actor/d_a_b_gnd.h"
 #include "d/d_com_inf_game.h"
 
+#if TARGET_PC
+#include "dusk/dvd_asset.hpp"
+static u8* l_Egnd_mantTEX_get()   { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0x1C00, 0x4000), true); return buf; }
+static u8* l_Egnd_mantTEX_U_get() { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0x5C00, 0x4000), true); return buf; }
+static u8* l_Egnd_mantPAL_get()   { alignas(32) static u8 buf[0x60];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0x9C00, 0x60),   true); return buf; }
+#define l_Egnd_mantTEX   (l_Egnd_mantTEX_get())
+#define l_Egnd_mantTEX_U (l_Egnd_mantTEX_U_get())
+#define l_Egnd_mantPAL   (l_Egnd_mantPAL_get())
+#else
 #include "assets/l_Egnd_mantTEX.h"
 
 #include "assets/l_Egnd_mantTEX_U.h"
 
 #include "assets/l_Egnd_mantPAL.h"
+#endif
 #include "d/d_s_play.h"
 
 static u32 l_pos[507] = {
@@ -239,20 +249,32 @@ static u32 l_texCoord[338] = {
     0x3F800000, 0x00000000,
 };
 
+#if TARGET_PC
+static u8* l_Egnd_mantDL_get() { alignas(32) static u8 buf[0x3EC]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", 0xA9A0, 0x3EC), true); return buf; }
+#define l_Egnd_mantDL (l_Egnd_mantDL_get())
+#else
 #include "assets/l_Egnd_mantDL.h"
+#endif
 
+#if !TARGET_PC
 static void* pal_d = (void*)&l_Egnd_mantPAL;
 
 static void* tex_d[2] = {
     (void*)&l_Egnd_mantTEX,
     (void*)&l_Egnd_mantTEX_U,
 };
+#endif
 
 static char lbl_277_bss_0;
 
 void daMant_packet_c::draw() {
+#if TARGET_PC
+    void* image = l_Egnd_mantTEX;
+    void* lut = l_Egnd_mantPAL;
+#else
     void* image = tex_d[0];
     void* lut = pal_d;
+#endif
 
     j3dSys.reinitGX();
     GXSetNumIndStages(0);
@@ -268,9 +290,9 @@ void daMant_packet_c::draw() {
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_CLR_RGB, GX_F32, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_F32, 0);
 
-    GXSETARRAY(GX_VA_POS, this->getPos(), sizeof(mPos[0]), 12);
-    GXSETARRAY(GX_VA_NRM, this->getNrm(), sizeof(mNrm[0]), 12);
-    GXSETARRAY(GX_VA_TEX0, &l_texCoord, sizeof(l_texCoord), 8);
+    GXSETARRAY(GX_VA_POS, this->getPos(), sizeof(mPos[0]), 12, true);
+    GXSETARRAY(GX_VA_NRM, this->getNrm(), sizeof(mNrm[0]), 12, true);
+    GXSETARRAY(GX_VA_TEX0, &l_texCoord, sizeof(l_texCoord), 8, false); // TODO: set to true when converted to float literals
 
     GXSetZCompLoc(0);
     GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);

src/d/actor/d_a_midna.cpp

@@ -1834,12 +1834,12 @@ void daMidna_c::setBckAnime(J3DAnmTransform* i_bck, int i_attr, f32 i_morf) {
         }
     } else {
         u8* buf = mBckHeap[0].getBuffer();
-        if (*(u32*)(buf + 0x1c) == 0xffffffff) {
+        if (*(BE(u32)*)(buf + 0x1c) == 0xffffffff) {
             offStateFlg1(FLG1_UNK_800);
             bas = NULL;
         } else {
             onStateFlg1(FLG1_UNK_800);
-            bas = mBckHeap[0].getBuffer() + *(u32*)(buf + 0x1c);
+            bas = mBckHeap[0].getBuffer() + *(BE(u32)*)(buf + 0x1c);
         }
     }
 
@@ -3046,12 +3046,17 @@ void daMidna_c::setMidnaNoDrawFlg() {
 
 BOOL daMidna_c::checkMetamorphoseEnableBase() {
     BOOL tmp;
-    if (
-        !daAlink_getAlinkActorClass()->checkMidnaRide() || (g_env_light.mEvilInitialized & 0x80) ||
+    if (!daAlink_getAlinkActorClass()->checkMidnaRide() || (g_env_light.mEvilInitialized & 0x80) ||
         /* dSv_event_flag_c::M_077 - Main Event - Get shadow crystal (can now transform) */
         !dComIfGs_isEventBit(0xD04) ||
+#if TARGET_PC
+        (fopAcIt_Judge((fopAcIt_JudgeFunc)daMidna_searchNpc, &tmp) &&
+         !dusk::getSettings().game.canTransformAnywhere)
+#else
         fopAcIt_Judge((fopAcIt_JudgeFunc)daMidna_searchNpc, &tmp)
-    ) {
+#endif
+    )
+    {
         return FALSE;
     }
     return TRUE;

src/d/actor/d_a_movie_player.cpp

@@ -14,21 +14,41 @@
 #pragma optimization_level 4
 #pragma optimize_for_size off
 
-#include "JSystem/JKernel/JKRExpHeap.h"
+#include <cstring>
+#include <span>
 #include "JSystem/JAudio2/JASAiCtrl.h"
 #include "JSystem/JAudio2/JASDriverIF.h"
-#include "d/actor/d_a_movie_player.h"
+#include "JSystem/JKernel/JKRExpHeap.h"
 #include "Z2AudioLib/Z2Instances.h"
+#include "d/actor/d_a_movie_player.h"
+
+#include <cassert>
+
 #include "f_op/f_op_overlap_mng.h"
-#include <cstring>
 
 #include "dusk/gx_helper.h"
+#include "dusk/os.h"
+#include "dusk/layout.hpp"
+
+#include "JSystem/JAudio2/JASCriticalSection.h"
+
+#if MOVIE_SUPPORT
+#include "turbojpeg.h"
+#endif
 
 inline s32 daMP_NEXT_READ_SIZE(daMP_THPReadBuffer* readBuf) {
-    return *(s32*)readBuf->ptr;
+    return *(BE(s32)*)readBuf->ptr;
 }
 
-#ifdef __cplusplus
+#if TARGET_PC
+// idk what OS_THREAD_ATTR_DETACH does, and it stops OSThreadJoin()
+// probably the difference doesn't matter since we are using OS threads anyways.
+#define OS_THREAD_ATTR 0
+#else
+#define OS_THREAD_ATTR OS_THREAD_ATTR_DETACH
+#endif
+
+#if defined(__cplusplus) && !TARGET_PC
 extern "C" {
 #endif
 
@@ -196,6 +216,7 @@ static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr) {
     info->encodeData++;
 }
 
+#if !TARGET_PC
 static u8 THPStatistics[1120] ATTRIBUTE_ALIGN(32);
 
 static THPHuffmanTab* Ydchuff ATTRIBUTE_ALIGN(32);
@@ -2562,8 +2583,109 @@ static void __THPHuffDecodeDCTCompV(__REGISTER THPFileInfo* info, THPCoeff* bloc
         }
     }
 }
+#else // !TARGET_PC
+
+static daMP_THPPlayer daMP_ActivePlayer;
+
+#if MOVIE_SUPPORT
+static std::vector<u8> FixedJpegData;
+static tjhandle JpegDecompressHandle;
+
+static const std::vector<u8>& FixJpeg(const std::span<u8> data) {
+    FixedJpegData.resize(0);
+    FixedJpegData.reserve(data.size());
+
+    size_t startOfScanLocation = 0;
+    for (; startOfScanLocation < data.size() - 1; startOfScanLocation++) {
+        if (data[startOfScanLocation] == 0xFF && data[startOfScanLocation + 1] == 0xDA) {
+            goto sosFound;
+        }
+    }
+
+    CRASH("Unable to find SOS marker!");
+
+    sosFound:
+
+    startOfScanLocation += 2; // TODO: Skip entire SOS header?
+
+    size_t endOfImage = data.size() - 1;
+    for (; endOfImage > startOfScanLocation; endOfImage--) {
+        if (data[endOfImage] == 0xFF && data[endOfImage + 1] == 0xD9) {
+            goto eoiFound;
+        }
+    }
+
+    CRASH("Unable to find EOI marker!");
+    eoiFound:
+
+    // Copy data before SOS
+    for (size_t i = 0; i < startOfScanLocation; i++) {
+        FixedJpegData.push_back(data[i]);
+    }
+
+    // Copy data inside SOS, fixing up lacking of "byte shuffling"
+    for (size_t i = startOfScanLocation; i < endOfImage; i++) {
+        u8 value = data[i];
+        FixedJpegData.push_back(value);
+        if (value == 0xFF) {
+            FixedJpegData.push_back(0x00);
+        }
+    }
+
+    // Copy data after SOS.
+    for (size_t i = endOfImage; i < data.size(); i++) {
+        FixedJpegData.push_back(data[i]);
+    }
+
+    return FixedJpegData;
+}
+
+static s32 THPVideoDecode(void* file, size_t fileSize, void* tileY, void* tileU, void* tileV, void*) {
+    assert(JpegDecompressHandle);
+
+    const auto handle = JpegDecompressHandle;
+    const auto fixedData = FixJpeg(std::span(static_cast<u8*>(file), fileSize));
+
+    auto ret = tj3DecompressHeader(handle, fixedData.data(), fixedData.size());
+    if (ret == -1) {
+        OSReport_Error("Parsing JPEG header failed: %s", tj3GetErrorStr(handle));
+        return 1;
+    }
+
+    if (tj3Get(handle, TJPARAM_JPEGWIDTH) != daMP_ActivePlayer.videoInfo.xSize) {
+        OSReport_Error("Invalid width in video frame!");
+        return 1;
+    }
+
+    if (tj3Get(handle, TJPARAM_JPEGHEIGHT) != daMP_ActivePlayer.videoInfo.ySize) {
+        OSReport_Error("Invalid height in video frame!");
+        return 1;
+    }
+
+    ret = tj3Set(handle, TJPARAM_SUBSAMP, TJSAMP_420);
+    if (ret != 0) {
+        OSReport_Error("Failed to set subsampling mode: %s", tj3GetErrorStr(handle));
+        return 1;
+    }
+
+    u8* planes[3] = {static_cast<u8*>(tileY), static_cast<u8*>(tileU), static_cast<u8*>(tileV)};
+    ret = tj3DecompressToYUVPlanes8(handle, fixedData.data(), fixedData.size(), planes, nullptr);
+    if (ret != 0) {
+        OSReport_Error("Image decompression failed: %s", tj3GetErrorStr(handle));
+        return 1;
+    }
+
+    return 0;
+}
+#else // MOVIE_SUPPORT
+static s32 THPVideoDecode(void*, size_t, void*, void*, void*, void*) {
+    return 1; // Immediate error.
+}
+#endif
+#endif
 
 static BOOL THPInit() {
+#if !TARGET_PC
     u8* base;
     base = (u8*)(0xE000 << 16);
 
@@ -2585,15 +2707,21 @@ static BOOL THPInit() {
     OSInitFastCast();
 
     __THPInitFlag = TRUE;
+#endif
     return TRUE;
 }
 
-#ifdef __cplusplus
+#if defined(__cplusplus) && !TARGET_PC
 }
 #endif
 
+#if !TARGET_PC // Defined earlier in file.
 static daMP_THPPlayer daMP_ActivePlayer;
+#endif
 
+#if TARGET_PC
+static BOOL ReadThreadCancelled;
+#endif
 static BOOL daMP_ReadThreadCreated;
 
 static OSMessageQueue daMP_FreeReadBufferQueue;
@@ -2648,12 +2776,23 @@ void daMP_ReadThreadStart() {
 
 void daMP_ReadThreadCancel() {
     if (daMP_ReadThreadCreated) {
+#if TARGET_PC
+        ReadThreadCancelled = TRUE;
+        OSReceiveMessage(&daMP_ReadedBufferQueue, nullptr, OS_MESSAGE_NOBLOCK);
+        OSSendMessage(&daMP_FreeReadBufferQueue, nullptr, OS_MESSAGE_NOBLOCK);
+        OSJoinThread(&daMP_ReadThread, nullptr);
+#else
         OSCancelThread(&daMP_ReadThread);
+#endif
         daMP_ReadThreadCreated = FALSE;
     }
 }
 
 void* daMP_Reader(void*) {
+#if TARGET_PC
+    OSSetCurrentThreadName("movie player reader");
+#endif
+
     daMP_THPReadBuffer* buf;
 	s32 curFrame;
 	s32 status;
@@ -2664,8 +2803,17 @@ void* daMP_Reader(void*) {
     offset = daMP_ActivePlayer.initOffset;
 	initReadSize = daMP_ActivePlayer.initReadSize;
 
+#if TARGET_PC
+	while (!ReadThreadCancelled) {
+#else
 	while (TRUE) {
+#endif
 		buf = (daMP_THPReadBuffer*)daMP_PopFreeReadBuffer();
+#if TARGET_PC
+	    if (!buf) {
+	        return nullptr;
+	    }
+#endif
 		status = DVDReadPrio(&daMP_ActivePlayer.fileInfo, buf->ptr, initReadSize, offset, 2);
 		if (status != initReadSize) {
 			if (status == -1)
@@ -2673,7 +2821,11 @@ void* daMP_Reader(void*) {
 			if (frame == 0)
 				daMP_PrepareReady(FALSE);
 
+#if TARGET_PC
+		    return nullptr;
+#else
 			OSSuspendThread(&daMP_ReadThread);
+#endif
 		}
 
 		buf->frameNumber = frame;
@@ -2686,20 +2838,35 @@ void* daMP_Reader(void*) {
 		if (curFrame == daMP_ActivePlayer.header.numFrames - 1) {
 			if (daMP_ActivePlayer.playFlag & 1)
 				offset = daMP_ActivePlayer.header.movieDataOffsets;
-			else
-				OSSuspendThread(&daMP_ReadThread);
+			else {
+#if TARGET_PC
+			    return nullptr;
+#else
+			    OSSuspendThread(&daMP_ReadThread);
+#endif
+			}
 		}
 
 		frame++;
 	}
+
+#if TARGET_PC
+    return nullptr;
+#endif
 }
 
 static u8 daMP_ReadThreadStack[0x2000];
 
+#if TARGET_PC
+static BOOL VideoThreadCancelled;
+#endif
 static BOOL daMP_VideoDecodeThreadCreated;
 
 static BOOL daMP_CreateReadThread(s32 param_0) {
-    if (!OSCreateThread(&daMP_ReadThread, daMP_Reader, 0, daMP_ReadThreadStack + sizeof(daMP_ReadThreadStack), sizeof(daMP_ReadThreadStack), param_0, 1)) {
+#if TARGET_PC
+    ReadThreadCancelled = FALSE;
+#endif
+    if (!OSCreateThread(&daMP_ReadThread, daMP_Reader, 0, daMP_ReadThreadStack + sizeof(daMP_ReadThreadStack), sizeof(daMP_ReadThreadStack), param_0, OS_THREAD_ATTR)) {
         OSReport("Can't create read thread\n");
         return FALSE;
     }
@@ -2751,19 +2918,30 @@ static BOOL daMP_First;
 static void daMP_VideoDecode(daMP_THPReadBuffer* readBuffer) {
     THPTextureSet* textureSet;
 	s32 i;
-	u32* tileOffsets;
+	BE(u32)* tileOffsets;
 	u8* tile;
 
-    tileOffsets = (u32*)(readBuffer->ptr + 8);
+    tileOffsets = (BE(u32)*)(readBuffer->ptr + 8);
 	tile = &readBuffer->ptr[daMP_ActivePlayer.compInfo.numComponents * 4] + 8;
 	textureSet = (THPTextureSet*)daMP_PopFreeTextureSet();
 
+#if TARGET_PC
+    if (textureSet == nullptr) {
+        return;
+    }
+#endif
+
     for (i = 0; i < daMP_ActivePlayer.compInfo.numComponents; i++) {
         switch (daMP_ActivePlayer.compInfo.frameComp[i]) {
 		case 0: {
 			if ((daMP_ActivePlayer.videoError = THPVideoDecode(
-			         tile, textureSet->ytexture, textureSet->utexture,
-			         textureSet->vtexture, daMP_ActivePlayer.thpWork))) {
+			        tile,
+#if TARGET_PC
+	                *tileOffsets,
+#endif
+			         textureSet->ytexture, textureSet->utexture,
+			         textureSet->vtexture,
+			         daMP_ActivePlayer.thpWork))) {
 				if (daMP_First) {
 					daMP_PrepareReady(FALSE);
 					daMP_First = FALSE;
@@ -2789,12 +2967,24 @@ static void daMP_VideoDecode(daMP_THPReadBuffer* readBuffer) {
 }
 
 static void* daMP_VideoDecoder(void* param_0) {
-    daMP_THPReadBuffer* thpBuffer;
+#if TARGET_PC
+    OSSetCurrentThreadName("movie video decoder");
+#endif
 
+    daMP_THPReadBuffer* thpBuffer;
+#if TARGET_PC
+	while (!VideoThreadCancelled) {
+#else
 	while (TRUE) {
+#endif
 		if (daMP_ActivePlayer.audioExist) {
 			for (; daMP_ActivePlayer.videoDecodeCount < 0;) {
 				thpBuffer = (daMP_THPReadBuffer*)daMP_PopReadedBuffer2();
+#if TARGET_PC
+			    if (thpBuffer == nullptr) {
+			        goto exit;
+			    }
+#endif
 				s32 remaining
 				    = ((thpBuffer->frameNumber + daMP_ActivePlayer.initReadFrame)
 				       % daMP_ActivePlayer.header.numFrames);
@@ -2814,12 +3004,26 @@ static void* daMP_VideoDecoder(void* param_0) {
 		else
 			thpBuffer = (daMP_THPReadBuffer*)daMP_PopReadedBuffer();
 
+#if TARGET_PC
+	    if (thpBuffer == nullptr) {
+	        goto exit;
+	    }
+#endif
+
 		daMP_VideoDecode(thpBuffer);
 		daMP_PushFreeReadBuffer(thpBuffer);
 	}
+#if TARGET_PC
+    exit:;
+    return nullptr;
+#endif
 }
 
 static void* daMP_VideoDecoderForOnMemory(void* param_0) {
+#if TARGET_PC
+    OSSetCurrentThreadName("movie video decoder");
+#endif
+
     daMP_THPReadBuffer readBuffer;
 	s32 readSize;
 	s32 frame;
@@ -2876,13 +3080,17 @@ static void* daMP_VideoDecoderForOnMemory(void* param_0) {
 }
 
 static BOOL daMP_CreateVideoDecodeThread(OSPriority prio, u8* param_1) {
+#if TARGET_PC
+    VideoThreadCancelled = FALSE;
+#endif
+
     if (param_1 != NULL) {
-        if (!OSCreateThread(&daMP_VideoDecodeThread, daMP_VideoDecoderForOnMemory, param_1, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), prio, 1)) {
+        if (!OSCreateThread(&daMP_VideoDecodeThread, daMP_VideoDecoderForOnMemory, param_1, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), prio, OS_THREAD_ATTR)) {
             OSReport("Can't create video decode thread\n");
             return FALSE;
         }
     } else {
-        if (!OSCreateThread(&daMP_VideoDecodeThread, daMP_VideoDecoder, NULL, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), prio, 1)) {
+        if (!OSCreateThread(&daMP_VideoDecodeThread, daMP_VideoDecoder, NULL, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), prio, OS_THREAD_ATTR)) {
             OSReport("Can't create video decode thread\n");
             return FALSE;
         }
@@ -2903,12 +3111,24 @@ static void daMP_VideoDecodeThreadStart() {
 
 void daMP_VideoDecodeThreadCancel() {
     if (daMP_VideoDecodeThreadCreated) {
+#if TARGET_PC
+        VideoThreadCancelled = TRUE;
+        // Push junk into the queues so the thread unblocks and can exit cleanly.
+        daMP_PushFreeTextureSet(nullptr);
+        daMP_PushReadedBuffer(nullptr);
+        daMP_PushReadedBuffer2(nullptr);
+        OSJoinThread(&daMP_VideoDecodeThread, nullptr);
+#else
         OSCancelThread(&daMP_VideoDecodeThread);
+#endif
         daMP_VideoDecodeThreadCreated = FALSE;
     }
 }
 
 static BOOL daMP_AudioDecodeThreadCreated;
+#if TARGET_PC
+static BOOL AudioThreadCancelled;
+#endif
 
 static OSThread daMP_AudioDecodeThread;
 
@@ -2944,12 +3164,17 @@ static void daMP_PushDecodedAudioBuffer(void* buffer) {
 static void daMP_AudioDecode(daMP_THPReadBuffer* readBuffer) {
     THPAudioBuffer* audioBuf;
 	s32 i;
-	u32* offsets;
+	BE(u32)* offsets;
 	u8* audioData;
 
-	offsets = (u32*)(readBuffer->ptr + 8);
+	offsets = (BE(u32)*)(readBuffer->ptr + 8);
 	audioData = &readBuffer->ptr[daMP_ActivePlayer.compInfo.numComponents * 4] + 8;
 	audioBuf = (THPAudioBuffer*)daMP_PopFreeAudioBuffer();
+#if TARGET_PC
+    if (!audioBuf) {
+        return;
+    }
+#endif
 
 	for (i = 0; i < daMP_ActivePlayer.compInfo.numComponents; i++) {
 		switch (daMP_ActivePlayer.compInfo.frameComp[i]) {
@@ -2969,16 +3194,34 @@ static void daMP_AudioDecode(daMP_THPReadBuffer* readBuffer) {
 }
 
 static void* daMP_AudioDecoder(void* param_0) {
+#if TARGET_PC
+    OSSetCurrentThreadName("movie audio decoder");
+#endif
+
     daMP_THPReadBuffer* buf;
 
+#if TARGET_PC
+    while (!AudioThreadCancelled) {
+#else
     while (TRUE) {
+#endif
         buf = (daMP_THPReadBuffer*)daMP_PopReadedBuffer();
+#if TARGET_PC
+        if (!buf) {
+            return nullptr;
+        }
+#endif
         daMP_AudioDecode(buf);
         daMP_PushReadedBuffer2(buf);
     }
+    return nullptr;
 }
 
 static void* daMP_AudioDecoderForOnMemory(void* param_0) {
+#if TARGET_PC
+    OSSetCurrentThreadName("movie audio decoder");
+#endif
+
     s32 size;
 	s32 readSize;
 	daMP_THPReadBuffer readBuffer;
@@ -2989,7 +3232,11 @@ static void* daMP_AudioDecoderForOnMemory(void* param_0) {
 	readBuffer.ptr = (u8*)param_0;
     frame = 0;
 
+#if TARGET_PC
+	while (!AudioThreadCancelled) {
+#else
 	while (TRUE) {
+#endif
 		readBuffer.frameNumber = frame;
 		daMP_AudioDecode(&readBuffer);
 
@@ -2999,7 +3246,11 @@ static void* daMP_AudioDecoderForOnMemory(void* param_0) {
 				readSize = *(s32*)readBuffer.ptr;
 				readBuffer.ptr = daMP_ActivePlayer.movieData;
 			} else {
+#if TARGET_PC
+			    return nullptr;
+#else
 				OSSuspendThread(&daMP_AudioDecodeThread);
+#endif
 			}
 		} else {
 			size = *(s32*)readBuffer.ptr;
@@ -3008,6 +3259,7 @@ static void* daMP_AudioDecoderForOnMemory(void* param_0) {
 		}
 		frame++;
 	}
+    return nullptr;
 }
 
 static OSMessage daMP_FreeAudioBufferMessage[3];
@@ -3015,13 +3267,16 @@ static OSMessage daMP_FreeAudioBufferMessage[3];
 static OSMessage daMP_DecodedAudioBufferMessage[3];
 
 static BOOL daMP_CreateAudioDecodeThread(OSPriority prio, u8* param_1) {
+#if TARGET_PC
+    AudioThreadCancelled = FALSE;
+#endif
     if (param_1 != NULL) {
-        if (!OSCreateThread(&daMP_AudioDecodeThread, daMP_AudioDecoderForOnMemory, param_1, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), prio, 1)) {
+        if (!OSCreateThread(&daMP_AudioDecodeThread, daMP_AudioDecoderForOnMemory, param_1, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), prio, OS_THREAD_ATTR)) {
             OS_REPORT("Can't create audio decode thread\n");
             return FALSE;
         }
     } else {
-        if (!OSCreateThread(&daMP_AudioDecodeThread, daMP_AudioDecoder, NULL, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), prio, 1)) {
+        if (!OSCreateThread(&daMP_AudioDecodeThread, daMP_AudioDecoder, NULL, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), prio, OS_THREAD_ATTR)) {
             OSReport("Can't create audio decode thread\n");
             return FALSE;
         }
@@ -3042,7 +3297,17 @@ void daMP_AudioDecodeThreadStart() {
 
 void daMP_AudioDecodeThreadCancel() {
     if (daMP_AudioDecodeThreadCreated) {
+#if TARGET_PC
+        AudioThreadCancelled = TRUE;
+        // Push junk into the queues so the thread unblocks and can exit cleanly.
+        OSSendMessage(&daMP_ReadedBufferQueue, nullptr, OS_MESSAGE_NOBLOCK);
+        daMP_PushFreeAudioBuffer(nullptr);
+        OSReceiveMessage(&daMP_ReadedBufferQueue2, nullptr, OS_MESSAGE_NOBLOCK);
+        OSReceiveMessage(&daMP_DecodedAudioBufferQueue, nullptr, OS_MESSAGE_NOBLOCK);
+        OSJoinThread(&daMP_AudioDecodeThread, nullptr);
+#else
         OSCancelThread(&daMP_AudioDecodeThread);
+#endif
         daMP_AudioDecodeThreadCreated = FALSE;
     }
 }
@@ -3077,8 +3342,13 @@ static void daMP_THPGXYuv2RgbSetup(const GXRenderModeObj* rmode) {
 	Mtx44 m;
 	Mtx e_m;
 
+#if TARGET_PC
+    w = JUTVideo::getManager()->getFbWidth();
+    h = JUTVideo::getManager()->getEfbHeight();
+#else
     w = rmode->fbWidth;
     h = rmode->efbHeight;
+#endif
     var_f31 = 0.0f;
 
     #if WIDESCREEN_SUPPORT
@@ -3168,19 +3438,26 @@ static void daMP_THPGXYuv2RgbDraw(u8* y_data, u8* u_data, u8* v_data, s16 x,
     TGXTexObj tobj0;
     TGXTexObj tobj1;
     TGXTexObj tobj2;
+#if TARGET_PC
+#define FMT (GXTexFmt)GX_TF_R8_PC
+#else
+#define FMT GX_TF_I8
+#endif
 
-    GXInitTexObj(&tobj0, y_data, textureWidth, textureHeight, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
+    GXInitTexObj(&tobj0, y_data, textureWidth, textureHeight, FMT, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(&tobj0, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
     GXLoadTexObj(&tobj0, GX_TEXMAP0);
 
-    GXInitTexObj(&tobj1, u_data, textureWidth >> 1, textureHeight >> 1, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
+    GXInitTexObj(&tobj1, u_data, textureWidth >> 1, textureHeight >> 1, FMT, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(&tobj1, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
     GXLoadTexObj(&tobj1, GX_TEXMAP1);
 
-    GXInitTexObj(&tobj2, v_data, textureWidth >> 1, textureHeight >> 1, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
+    GXInitTexObj(&tobj2, v_data, textureWidth >> 1, textureHeight >> 1, FMT, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(&tobj2, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
     GXLoadTexObj(&tobj2, GX_TEXMAP2);
 
+#undef FMT
+
     GXBegin(GX_QUADS, GX_VTXFMT7, 4);
     GXPosition3s16(x, y, 0);
     GXTexCoord2u16(0, 0);
@@ -3191,6 +3468,12 @@ static void daMP_THPGXYuv2RgbDraw(u8* y_data, u8* u_data, u8* v_data, s16 x,
     GXPosition3s16(x, y + polygonHeight, 0);
     GXTexCoord2u16(0, 1);
     GXEnd();
+
+#if TARGET_PC
+    GXDestroyTexObj(&tobj0);
+    GXDestroyTexObj(&tobj1);
+    GXDestroyTexObj(&tobj2);
+#endif
 }
 
 static u16 daMP_VolumeTable[] = {
@@ -3268,7 +3551,7 @@ static void daMP_MixAudio(s16* destination, s16*, u32 sample) {
 				if (r_mix > 32767)
 					r_mix = 32767;
 
-                if (JASDriver::getOutputMode() == 0) {
+                if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
                     l_mix = r_mix = ((r_mix >> 1) + (l_mix >> 1));
                     r_mix = (s16)r_mix;
                     l_mix = (s16)l_mix;
@@ -3495,6 +3778,13 @@ static BOOL daMP_THPPlayerOpen(char const* filename, BOOL onMemory) {
 }
 
 static BOOL daMP_THPPlayerClose() {
+#if TARGET_PC && MOVIE_SUPPORT
+    tj3Destroy(JpegDecompressHandle);
+    JpegDecompressHandle = nullptr;
+
+    FixedJpegData.clear();
+#endif
+
     if (daMP_ActivePlayer.open && daMP_ActivePlayer.state == 0) {
         daMP_ActivePlayer.open = 0;
         DVDClose(&daMP_ActivePlayer.fileInfo);
@@ -3546,6 +3836,11 @@ static BOOL daMP_THPPlayerSetBuffer(u8* buffer) {
 
 		ysize = ALIGN_NEXT(daMP_ActivePlayer.videoInfo.xSize * daMP_ActivePlayer.videoInfo.ySize, 32);
 		uvsize = ALIGN_NEXT(daMP_ActivePlayer.videoInfo.xSize * daMP_ActivePlayer.videoInfo.ySize / 4, 32);
+#if TARGET_PC
+	    assert(ysize >= tj3YUVPlaneSize(0, daMP_ActivePlayer.videoInfo.xSize, 0, daMP_ActivePlayer.videoInfo.ySize, TJSAMP_420));
+	    assert(uvsize >= tj3YUVPlaneSize(1, daMP_ActivePlayer.videoInfo.xSize, 0, daMP_ActivePlayer.videoInfo.ySize, TJSAMP_420));
+	    assert(uvsize >= tj3YUVPlaneSize(2, daMP_ActivePlayer.videoInfo.xSize, 0, daMP_ActivePlayer.videoInfo.ySize, TJSAMP_420));
+#endif
 
 		for (i = 0; i < ARRAY_SIZE(daMP_ActivePlayer.textureSet); i++) {
 			daMP_ActivePlayer.textureSet[i].ytexture = ptr;
@@ -3623,6 +3918,12 @@ static BOOL daMP_ProperTimingForGettingNextFrame() {
 		}
 	} else {
 		s32 frameRate = daMP_ActivePlayer.header.frameRate * 100.0f;
+#if TARGET_PC
+	    // DUSK HACK: We only fire retrace callbacks *half* as often as the game expects,
+	    // because we only run them once per frame, and normally there should be two scans
+	    // per game frame.
+	    frameRate *= 2;
+#endif
 		if (VIGetTvFormat() == VI_PAL) {
 			daMP_ActivePlayer.curCount = daMP_ActivePlayer.retaceCount * frameRate / 5000;
 		} else {
@@ -3951,6 +4252,9 @@ static BOOL daMP_THPPlayerSetVolume(s32 vol, s32 duration) {
 		if (duration < 0)
 			duration = 0;
 
+#if TARGET_PC
+	    JASCriticalSection section;
+#endif
 		interrupt = OSDisableInterrupts();
 
 		daMP_ActivePlayer.targetVolume = vol;
@@ -3994,11 +4298,14 @@ static BOOL daMP_ActivePlayer_Init(char const* moviePath) {
     daMP_THPPlayerGetVideoInfo(&daMP_videoInfo);
     daMP_THPPlayerGetAudioInfo(&daMP_audioInfo);
 
+#if !TARGET_PC
+    // Window can be resized during playback, update this during draw.
     u16 width = JUTVideo::getManager()->getRenderMode()->fbWidth;
     u16 height = JUTVideo::getManager()->getRenderMode()->efbHeight;
 
     daMP_DrawPosX = (width - daMP_videoInfo.xSize) >> 1;
     daMP_DrawPosY = (height - daMP_videoInfo.ySize) >> 1;
+#endif
 
     // "The memory needed for this THP movie is %d bytes\n"
     OS_REPORT("このＴＨＰムービーが必要なメモリは%dバイトです\n", daMP_THPPlayerCalcNeedMemory());
@@ -4015,6 +4322,15 @@ static BOOL daMP_ActivePlayer_Init(char const* moviePath) {
 
     daMP_THPPlayerSetBuffer((u8*)daMP_buffer);
 
+#if TARGET_PC && MOVIE_SUPPORT
+    assert(JpegDecompressHandle == nullptr);
+    JpegDecompressHandle = tj3Init(TJINIT_DECOMPRESS);
+    if (JpegDecompressHandle == nullptr) {
+        OSReport_Error("Failed to create turbojpeg handle: %s", tj3GetErrorStr(nullptr));
+        return 0;
+    }
+#endif
+
     if (!daMP_THPPlayerPrepare(0, 0, daMP_audioInfo.sndNumTracks != 1 ? OSGetTick() % daMP_audioInfo.sndNumTracks : 0)) {
         OSReport("Fail to prepare\n");
         #if DEBUG
@@ -4050,14 +4366,55 @@ static void daMP_ActivePlayer_Main() {
     }
 }
 
+#if TARGET_PC && 0
+#include "imgui.h"
+#endif
+
 static void daMP_ActivePlayer_Draw() {
-    int frame = daMP_THPPlayerDrawCurrentFrame(JUTVideo::getManager()->getRenderMode(), daMP_DrawPosX, daMP_DrawPosY, daMP_videoInfo.xSize, daMP_videoInfo.ySize);
+#if TARGET_PC
+    u16 width = JUTVideo::getManager()->getFbWidth();
+    u16 height = JUTVideo::getManager()->getEfbHeight();
+
+    const auto rect = dusk::LayoutRect::FitRectInRect(
+        width,
+        height,
+        static_cast<f32>(daMP_videoInfo.xSize),
+        static_cast<f32>(daMP_videoInfo.ySize));
+
+    daMP_DrawPosX = static_cast<u32>(rect.PosX);
+    daMP_DrawPosY = static_cast<u32>(rect.PosY);
+#endif
+
+    int frame = daMP_THPPlayerDrawCurrentFrame(
+        JUTVideo::getManager()->getRenderMode(),
+        daMP_DrawPosX, daMP_DrawPosY,
+#if TARGET_PC
+        static_cast<u32>(rect.Width()),
+        static_cast<u32>(rect.Height()));
+#else
+        daMP_videoInfo.xSize,
+        daMP_videoInfo.ySize);
+#endif
     daMP_THPPlayerDrawDone();
 
     if (!fopOvlpM_IsPeek() && frame > 0 && (cAPICPad_ANY_BUTTON(0) || !daMP_c::daMP_c_Get_MovieRestFrame())) {
         dComIfGp_event_reset();
         daMP_c::daMP_c_Set_PercentMovieVolume(0.0f);
     }
+
+#if TARGET_PC && 0
+    if (ImGui::Begin("Movie player")) {
+        ImGui::Text("daMP_ReadedBufferQueue: %d", daMP_ReadedBufferQueue.usedCount);
+        ImGui::Text("daMP_ReadedBufferQueue2: %d", daMP_ReadedBufferQueue2.usedCount);
+        ImGui::Text("daMP_FreeReadBufferQueue: %d", daMP_FreeReadBufferQueue.usedCount);
+        ImGui::Text("daMP_DecodedTextureSetQueue: %d", daMP_DecodedTextureSetQueue.usedCount);
+        ImGui::Text("daMP_FreeTextureSetQueue: %d", daMP_FreeTextureSetQueue.usedCount);
+        ImGui::Text("daMP_DecodedAudioBufferQueue: %d", daMP_DecodedAudioBufferQueue.usedCount);
+        ImGui::Text("daMP_FreeAudioBufferQueue: %d", daMP_FreeAudioBufferQueue.usedCount);
+    }
+
+    ImGui::End();
+#endif
 }
 
 static BOOL daMP_Fail_alloc;
@@ -4116,7 +4473,9 @@ int daMP_c::daMP_c_Get_arg_movieNo() {
 int daMP_c::daMP_c_Init() {
     JUT_ASSERT(9469, m_myObj == NULL);
 
+#if !TARGET_PC // We don't properly simulate retrace interval so this doesn't work.
     mDoGph_gInf_c::setFrameRate(1);
+#endif
     daMP_Fail_alloc = FALSE;
 
     int demoNo = daMP_c_Get_arg_demoNo();

src/d/actor/d_a_myna.cpp

@@ -74,9 +74,9 @@ static char* l_bckFileNameTBL[] = {
 
 static char* l_btpFileNameTBL[] = {"MYNA.btp"};
 
-static void createHeapCallBack(fopAc_ac_c* i_this) {
+static int createHeapCallBack(fopAc_ac_c* i_this) {
     daMyna_c* a_this = static_cast<daMyna_c*>(i_this);
-    a_this->createHeap();
+    return a_this->createHeap();
 }
 
 static int jntNodeCallBack(J3DJoint* i_jnt, int param_1) {
@@ -339,7 +339,7 @@ int daMyna_c::create() {
         return phase;
     }
 
-    if (!fopAcM_entrySolidHeap(this, (heapCallbackFunc)&createHeapCallBack, 0x21F0)) {
+    if (!fopAcM_entrySolidHeap(this, createHeapCallBack, 0x21F0)) {
         return cPhs_ERROR_e;
     }
 

src/d/actor/d_a_npc.cpp

@@ -2694,16 +2694,15 @@ BOOL daNpcT_chkActorInScreen(fopAc_ac_c* i_ActorP, f32 param_1, f32 param_2, f32
         }
 
         for (int i = 0; i < 8; i++) {
+            #if TARGET_PC
+            mDoLib_project(&pos_array[i], &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+            #else
             mDoLib_project(&pos_array[i], &proj);
-#if TARGET_PC
-            if (0.0f < proj.x && proj.x < mDoGph_gInf_c::getWidth() && 0.0f < proj.y && proj.y < mDoGph_gInf_c::getHeight()) {
-                continue;
-            }
-#else
+            #endif
+
             if (0.0f < proj.x && proj.x < FB_WIDTH && 0.0f < proj.y && proj.y < FB_HEIGHT) {
                 continue;
             }
-#endif
             return false;
         }
 

src/d/actor/d_a_npc_grz.cpp

@@ -1363,7 +1363,15 @@ void daNpc_Grz_c::playExpression() {
     daNpcF_anmPlayData dat7 = {ANM_LIEDOWN, mpHIO->m.common.morf_frame, 0};
     daNpcF_anmPlayData* pDat7[1] = {&dat7};
     daNpcF_anmPlayData dat8 = {ANM_GETUP, mpHIO->m.common.morf_frame, 1};
-    daNpcF_anmPlayData* pDat8[1] = {&dat8};
+#if TARGET_PC
+    // BUG: If mNumLoops is non-zero, the data array MUST be null-terminated to prevent
+    // playExpression from reading junk when it increments the index.
+    // For some reason this doesn't crash on hardware, but it triggers a segfault on PC
+    // when first talking to Fyrus after defating him.
+    daNpcF_anmPlayData* pDat8[2] = {&dat8, NULL};
+#else
+    daNpcF_anmPlayData* pDat8[2] = {&dat8};
+#endif
     daNpcF_anmPlayData dat9 = {ANM_F_WEAK_WAIT, mpHIO->m.common.morf_frame, 0};
     daNpcF_anmPlayData* pDat9[1] = {&dat9};
     daNpcF_anmPlayData dat10 = {ANM_NONE, mpHIO->m.common.morf_frame, 0};

src/d/actor/d_a_npc_henna.cpp

@@ -2709,6 +2709,14 @@ static int daNpc_Henna_Create(fopAc_ac_c* i_this) {
         }
         i_this->attention_info.flags = (fopAc_AttnFlag_SPEAK_e | fopAc_AttnFlag_TALK_e);
         a_this->action = 0;
+
+#if AVOID_UB
+        a_this->field_0x654 = 0;
+        a_this->field_0x658 = 0;
+        a_this->field_0x662 = 0;
+        a_this->field_0x664 = 0;
+#endif
+
         fopAcM_SetMtx(i_this, a_this->mpMorf->getModel()->getBaseTRMtx());
         lbl_82_bss_90 = 0;
         if (a_this->arg0 == 1) {

src/d/actor/d_a_npc_sola.cpp

@@ -194,14 +194,13 @@ int daNpc_solA_c::Execute() {
     return execute();
 }
 
-void daNpc_solA_c::Draw() {
+int daNpc_solA_c::Draw() {
     if (mpMatAnm[0] != NULL) {
         J3DModelData* mdlData_p = mpMorf[0]->getModel()->getModelData();
         mdlData_p->getMaterialNodePointer(getEyeballMaterialNo())->setMaterialAnm(mpMatAnm[0]);
     }
-    draw(FALSE, FALSE, mpHIO->m.common.real_shadow_size, NULL, 100.0f, FALSE, FALSE,
-         FALSE);
-    return;
+    
+    return draw(FALSE, FALSE, mpHIO->m.common.real_shadow_size, NULL, 100.0f, FALSE, FALSE, FALSE);
 }
 
 BOOL daNpc_solA_c::createHeapCallBack(fopAc_ac_c* a_this) {
@@ -481,12 +480,12 @@ static int daNpc_solA_Execute(void* param_0) {
     return static_cast<daNpc_solA_c*>(param_0)->Execute();
 }
 
-static void daNpc_solA_Draw(void* param_0) {
+static int daNpc_solA_Draw(void* param_0) {
     return static_cast<daNpc_solA_c*>(param_0)->Draw();
 }
 
-static BOOL daNpc_solA_IsDelete(void* param_0) {
-    return TRUE;
+static int daNpc_solA_IsDelete(void* param_0) {
+    return 1;
 }
 
 static actor_method_class daNpc_solA_MethodTable = {

src/d/actor/d_a_npc_tk.cpp

@@ -2014,7 +2014,7 @@ void daNPC_TK_c::executeWolfPerch() {
         mWolfPathData = dPath_GetRoomPath(mpPath1->m_nextID, fopAcM_GetRoomNo(this));
         JUT_ASSERT(2498, mWolfPathData != NULL);
 
-        field_0x6ea = mWolfPathData->field_0x6;
+        field_0x6ea = mWolfPathData->swbit;
         field_0x6e8 = mWolfPathData->field_0x4;
         field_0x6e9 = mWolfPathData->field_0x7;
         field_0x6d0.Init(mWolfPathData);
@@ -2518,7 +2518,7 @@ void daNPC_TK_c::executeResistanceDemo() {
                            0x200, 0x10);
         shape_angle.x = -current.angle.x;
 
-        cLib_addCalcAngleS(&current.angle.y, cLib_targetAngleY((Vec*)&current, &posWithOffset), 8,
+        cLib_addCalcAngleS(&current.angle.y, cLib_targetAngleY(&current.pos, &posWithOffset), 8,
                            0x400, 0x10);
         shape_angle.y = current.angle.y;
 

src/d/actor/d_a_npc_tks.cpp

@@ -824,9 +824,11 @@ void daNpcTks_c::playMotion() {
     daNpcF_anmPlayData dat4b = {ANM_FLY, 0.0f, 0};
     daNpcF_anmPlayData* pDat4[2] = {&dat4a, &dat4b};
 
-    #if TARGET_PC
-    // Note: this fixes a crash in the cutscene after entering city and likely needs to be revisited as its
-    // unclear why this was 1 in the first place and unclear why this fixes it
+#if TARGET_PC
+    // BUG: If mNumLoops is non-zero, the data array MUST be null-terminated to prevent
+    // playExpression from reading junk when it increments the index.
+    // For some reason this doesn't crash on hardware, but it triggers a segfault on PC
+    // in the cutscene after entering city.
     daNpcF_anmPlayData dat5 = {ANM_JUMP_E, 0.0f, 0};
     #else
     daNpcF_anmPlayData dat5 = {ANM_JUMP_E, 0.0f, 1};

src/d/actor/d_a_obj_Y_taihou.cpp

@@ -356,21 +356,21 @@ int daObjYtaihou_c::Delete() {
     return 1;
 }
 
-static void daObjYtaihou_create1st(daObjYtaihou_c* i_this) {
+static int daObjYtaihou_create1st(daObjYtaihou_c* i_this) {
     fopAcM_ct(i_this, daObjYtaihou_c);
-    i_this->create1st();
+    return i_this->create1st();
 }
 
-static void daObjYtaihou_MoveBGDelete(daObjYtaihou_c* i_this) {
-    i_this->MoveBGDelete();
+static int daObjYtaihou_MoveBGDelete(daObjYtaihou_c* i_this) {
+    return i_this->MoveBGDelete();
 }
 
-static void daObjYtaihou_MoveBGExecute(daObjYtaihou_c* i_this) {
-    i_this->MoveBGExecute();
+static int daObjYtaihou_MoveBGExecute(daObjYtaihou_c* i_this) {
+    return i_this->MoveBGExecute();
 }
 
-static void daObjYtaihou_MoveBGDraw(daObjYtaihou_c* i_this) {
-    i_this->Draw();
+static int daObjYtaihou_MoveBGDraw(daObjYtaihou_c* i_this) {
+    return i_this->Draw();
 }
 
 static actor_method_class daObjYtaihou_METHODS = {

src/d/actor/d_a_obj_ari.cpp

@@ -499,7 +499,13 @@ void daObjARI_c::Z_BufferChk() {
     cXyz vec2, vec1;
     vec1 = current.pos;
     vec1.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&vec1, &vec2, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&vec1, &vec2);
+    #endif
+
     f32 trim_height;
     camera_process_class* camera = dComIfGp_getCamera(0);
     if (camera != NULL) {

src/d/actor/d_a_obj_bhashi.cpp

@@ -285,7 +285,13 @@ bool Hahen_c::CheckCull() {
 
 bool Hahen_c::checkViewArea() {
     Vec proj;
+
+    #if TARGET_PC
+    mDoLib_project(&pos, &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&pos, &proj);
+    #endif
+
     return (proj.x >= -50.0f && proj.x <= 658.0f) && (proj.y >= -50.0f && proj.y <= 498.0f);
 }
 

src/d/actor/d_a_obj_brg.cpp

@@ -16,6 +16,8 @@
 #include "f_op/f_op_camera_mng.h"
 #include <cstring>
 
+#include "dusk/logging.h"
+
 static void ride_call_back(dBgW* i_bgw, fopAc_ac_c* i_bgActor, fopAc_ac_c* i_rideActor) {
     obj_brg_class* a_this = (obj_brg_class*)i_bgActor;
 
@@ -588,8 +590,6 @@ static void cut_control2(obj_brg_class* i_this, br_s* i_part) {
 }
 
 static void himo_cut_control1(obj_brg_class* i_this, cXyz* param_1, f32 param_2) {
-    STUB_RET();
-
     cXyz sp74 = {};
     cXyz sp80 = {};
     cXyz sp8C = {};
@@ -1794,6 +1794,10 @@ static int daObj_Brg_Create(fopAc_ac_c* i_this) {
                 cXyz(334.0f, 85.0f, -16054.0f),
                 cXyz(334.0f, 150.0f, -16270.0f),
                 cXyz(334.0f, 216.0f, -16485.0f),
+#ifdef TARGET_PC
+                // Avoids out-of-bounds index (n=22)
+                cXyz(0.f, 0.f, 0.f),
+#endif
             };
 
             for (brno = 0; brno < a_this->field_0xb1ea; brno++) {

src/d/actor/d_a_obj_cho.cpp

@@ -289,7 +289,13 @@ void daObjCHO_c::Z_BufferChk() {
     cXyz vec2, vec1;
     vec1 = current.pos;
     vec1.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&vec1, &vec2, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&vec1, &vec2);
+    #endif
+
     f32 trim_height;
     camera_process_class* camera = dComIfGp_getCamera(0);
     if (camera != NULL) {

src/d/actor/d_a_obj_crvfence.cpp

@@ -224,7 +224,13 @@ void daObjCRVFENCE_c::NormalAction() {
 
 bool daObjCRVFENCE_c::checkViewArea(cXyz* param_1) {
     Vec sp24;
+
+    #if TARGET_PC
+    mDoLib_project(param_1, &sp24, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(param_1, &sp24);
+    #endif
+
     bool rv = false;
     bool bVar1 = false;
 

src/d/actor/d_a_obj_crvhahen.cpp

@@ -137,7 +137,12 @@ void daObjCRVHAHEN_c::CheckCull() {
 
 bool daObjCRVHAHEN_c::checkViewArea(cXyz* i_this) {
     Vec proj;
+
+    #if TARGET_PC
+    mDoLib_project(i_this, &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(i_this, &proj);
+    #endif
 
     bool ret = false;
 

src/d/actor/d_a_obj_dan.cpp

@@ -267,7 +267,13 @@ void daObjDAN_c::Z_BufferChk() {
     cXyz vec2, vec1;
     vec1 = current.pos;
     vec1.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&vec1, &vec2, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&vec1, &vec2);
+    #endif
+
     f32 trim_height;
     camera_process_class* camera = dComIfGp_getCamera(0);
     if (camera != NULL) {

src/d/actor/d_a_obj_drop.cpp

@@ -20,6 +20,8 @@
 #include "d/actor/d_a_e_ymb.h"
 #include "f_op/f_op_camera_mng.h"
 
+#include "dusk/settings.h"
+
 #if DEBUG
 daObjDrop_HIO_c l_HIO;
 #endif
@@ -261,8 +263,18 @@ int daObjDrop_c::modeParentWait() {
         }
 
         mModeAction = 1;
+
+#if TARGET_PC
+        mModeTimer = dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 20 : 40;
+        if (dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0) {
+            current.pos.y += 100.0f;
+        } else {
+            current.pos.y += 300.0f;
+        }
+#else
         mModeTimer = 40;
         current.pos.y += 300.0f;
+#endif
         mSound.startSound(Z2SE_OBJ_LIGHTDROP_APPEAR, 0, -1);
         break;
     case 1:
@@ -272,7 +284,11 @@ int daObjDrop_c::modeParentWait() {
         break;
     case 2:
         createBodyEffect();
+#if TARGET_PC
+        mModeTimer = dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0 ? 5 : 45;
+#else
         mModeTimer = 45;
+#endif
         mModeAction = 0;
         setMode(MODE_WAIT_e);
         break;
@@ -281,6 +297,18 @@ int daObjDrop_c::modeParentWait() {
     return 1;
 }
 
+#if TARGET_PC
+static inline BOOL checkGetCargoRide() {
+    if ((daPy_getPlayerActorClass()->checkCargoCarry() && strcmp(dComIfGp_getStartStageName(), "F_SP112") == 0) ||
+        dComIfGs_isLightDropGetFlag(dComIfGp_getStartStageDarkArea()))
+    {
+        return true;
+    }
+
+    return false;
+}
+#endif
+
 int daObjDrop_c::modeWait() {
     daPy_py_c* pplayer = daPy_getPlayerActorClass();
 
@@ -302,7 +330,32 @@ int daObjDrop_c::modeWait() {
     case 1:
     case 2:
     case 50:
+        #if TARGET_PC
+        if (dusk::getSettings().game.fastTears && dComIfGp_event_getMode() == 0) {
+            f32 player_dist = current.pos.abs(daPy_getPlayerActorClass()->current.pos);
+            f32 home_dist = current.pos.abs(home.pos);
+
+            if (checkGetCargoRide() && player_dist < 1000.0f) {
+                mTargetPos = pplayer->current.pos;
+                mTargetPos.y += 100.0f;
+
+                f32 temp = 3000.0f - home_dist;
+                if (temp < 0.0f) {
+                    temp = 0.0f;
+                }
+
+                cLib_chaseF(&speedF, (temp / 3000.0f) * 10.0f * (temp / 3000.0f), 1.0f);
+            } else {
+                mTargetPos = home.pos;
+                cLib_chaseF(&speedF, 2.0f, 0.5f);
+            }
+        } else {
+            cLib_chaseF(&speedF, 7.5f, 0.4f);
+        }
+        #else
         cLib_chaseF(&speedF, 7.5f, 0.4f);
+        #endif
+
         if (mModeAction == 1) {
             cLib_chasePos(&current.pos, mTargetPos, speedF);
         }

src/d/actor/d_a_obj_fan.cpp

@@ -310,9 +310,9 @@ int daObjFan_c::Delete() {
     return 1;
 }
 
-static void daObjFan_create1st(daObjFan_c* param_0) {
+static int daObjFan_create1st(daObjFan_c* param_0) {
     fopAcM_ct(param_0, daObjFan_c);
-    param_0->create1st();
+    return param_0->create1st();
 }
 
 static int daObjFan_MoveBGDelete(daObjFan_c* param_0) {

src/d/actor/d_a_obj_flag.cpp

@@ -16,7 +16,7 @@ daObjFlag_c::M_attrs const daObjFlag_c::M_attr = {
 };
 
 void daObjFlag_c::create_init() {
-    field_0x5dc = (*(u32*)dComIfG_getObjectRes(daSetBgObj_c::getArcName(this), "spec.dat")) & 0xffff;
+    field_0x5dc = (*(BE(u32)*)dComIfG_getObjectRes(daSetBgObj_c::getArcName(this), "spec.dat")) & 0xffff;
     mPos = cXyz(current.pos.x, current.pos.y + field_0x5dc, current.pos.z);
     mFlagJoints[0].mRv = (short)(cM_rnd() * 65535.0f);
     mFlagJoints[1].mRv = (short)(cM_rnd() * 65535.0f);

src/d/actor/d_a_obj_flag2.cpp

@@ -274,9 +274,9 @@ void FlagCloth_c::draw() {
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_CLR_RGB, GX_F32, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_F32, 0);
-    GXSETARRAY(GX_VA_POS, getPos(), sizeof(mPositions), sizeof(cXyz));
-    GXSETARRAY(GX_VA_NRM, getNormal(), sizeof(mNormals), sizeof(cXyz));
-    GXSETARRAY(GX_VA_TEX0, mpTexCoord, sizeof(mpTexCoord), 8);
+    GXSETARRAY(GX_VA_POS, getPos(), sizeof(mPositions), sizeof(cXyz), true);
+    GXSETARRAY(GX_VA_NRM, getNormal(), sizeof(mNormals), sizeof(cXyz), true);
+    GXSETARRAY(GX_VA_TEX0, mpTexCoord, sizeof(l_texCoord), 8, true);
     GXSetZCompLoc(GX_FALSE);
     GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
     GXLoadTexObj(&mTexObj, GX_TEXMAP0);
@@ -304,7 +304,7 @@ void FlagCloth_c::draw() {
     GXSetClipMode(GX_CLIP_ENABLE);
     GXSetCullMode(GX_CULL_BACK);
     GXCallDisplayList(l_pennant_flagDL, 0x80);
-    GXSETARRAY(GX_VA_NRM, getNormalBack(), sizeof(mNormalBacks), sizeof(cXyz));
+    GXSETARRAY(GX_VA_NRM, getNormalBack(), sizeof(mNormalBacks), sizeof(cXyz), true);
     GXSetCullMode(GX_CULL_FRONT);
     GXCallDisplayList(l_pennant_flagDL, 0x80);
     J3DShape::resetVcdVatCache();

src/d/actor/d_a_obj_flag3.cpp

@@ -233,9 +233,9 @@ inline void FlagCloth2_c::draw() {
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_CLR_RGB, GX_F32, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_F32, 0);
-    GXSETARRAY(GX_VA_POS, getPos(), sizeof(mPositions), sizeof(cXyz));
-    GXSETARRAY(GX_VA_NRM, getNormal(), sizeof(mNormals), sizeof(cXyz));
-    GXSETARRAY(GX_VA_TEX0, mTexCoord, sizeof(mTexCoord), 8);
+    GXSETARRAY(GX_VA_POS, getPos(), sizeof(mPositions), sizeof(cXyz), true);
+    GXSETARRAY(GX_VA_NRM, getNormal(), sizeof(mNormals), sizeof(cXyz), true);
+    GXSETARRAY(GX_VA_TEX0, mTexCoord, sizeof(mTexCoord), 8, true);
     GXSetZCompLoc(GX_FALSE);
     GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
     GXLoadTexObj(&mTexObj, GX_TEXMAP0);
@@ -276,7 +276,7 @@ inline void FlagCloth2_c::draw() {
         GXEnd();
     }
 
-    GXSETARRAY(GX_VA_NRM, getNormalBack(), sizeof(mNormalBacks), sizeof(cXyz));
+    GXSETARRAY(GX_VA_NRM, getNormalBack(), sizeof(mNormalBacks), sizeof(cXyz), true);
     GXSetCullMode(GX_CULL_FRONT);
 
     for (int i = 0; i < 5; i++) {

src/d/actor/d_a_obj_gomikabe.cpp

@@ -201,7 +201,13 @@ void daObjGOMIKABE_c::CheckCull() {
 
 bool daObjGOMIKABE_c::checkViewArea(cXyz param_1) {
     Vec local_24;
+
+    #if TARGET_PC
+    mDoLib_project(&param_1, &local_24, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&param_1, &local_24);
+    #endif
+
     bool rv = false;
     if (local_24.x >= 0.0f && local_24.x <= FB_WIDTH && local_24.y >= 0.0f && local_24.y <= FB_HEIGHT) {
         rv = true;

src/d/actor/d_a_obj_groundwater.cpp

@@ -300,11 +300,19 @@ int daGrdWater_c::Draw() {
         J3DTexMtxInfo* mtxInfo = &material->getTexGenBlock()->getTexMtx(0)->getTexMtxInfo();
         if (mtxInfo != NULL) {
             Mtx afStack_50;
+
+            #if TARGET_PC
+            C_MTXLightPerspective(afStack_50, dComIfGd_getView()->fovy, dComIfGd_getView()->aspect,
+                                  1.0f, 1.0f, dusk::getSettings().game.useWaterProjectionOffset ? -0.01f : 0.0f, 0.0f);
+            #else
             C_MTXLightPerspective(afStack_50, dComIfGd_getView()->fovy, dComIfGd_getView()->aspect,
                                   1.0f, 1.0f, -0.01f, 0.0f);
+            #endif
+
             #if WIDESCREEN_SUPPORT
             mDoGph_gInf_c::setWideZoomLightProjection(afStack_50);
             #endif
+
             mtxInfo->setEffectMtx(afStack_50);
             modelData2->simpleCalcMaterial(0, (MtxP)j3dDefaultMtx);
         }

src/d/actor/d_a_obj_hhashi.cpp

@@ -214,7 +214,13 @@ void daObjHHASHI_c::CheckCull() {
 
 bool daObjHHASHI_c::checkViewArea(int param_1) {
     Vec local_20;
+
+    #if TARGET_PC
+    mDoLib_project(&field_0x5b0[param_1], &local_20, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&field_0x5b0[param_1], &local_20);
+    #endif
+
     bool rv = false;
     if (local_20.x >= 0.0f && local_20.x <= FB_WIDTH && local_20.y >= 0.0f && local_20.y <= FB_HEIGHT) {
         rv = true;

src/d/actor/d_a_obj_inobone.cpp

@@ -89,8 +89,8 @@ static void* s_boar_sub(void* i_actor, void* i_data) {
     return NULL;
 }
 
-static void CheckCreateHeap(fopAc_ac_c* i_this) {
-    static_cast<daObjIBone_c*>(i_this)->CreateHeap();
+static int CheckCreateHeap(fopAc_ac_c* i_this) {
+    return static_cast<daObjIBone_c*>(i_this)->CreateHeap();
 }
 
 void daObjIBone_c::initBaseMtx() {
@@ -150,7 +150,7 @@ int daObjIBone_c::create() {
     int result = dComIfG_resLoad(&mPhase, l_arcName);
             
     if (result == cPhs_COMPLEATE_e) {
-        if (!fopAcM_entrySolidHeap(this, (heapCallbackFunc)CheckCreateHeap, 0x860)) {
+        if (!fopAcM_entrySolidHeap(this, CheckCreateHeap, 0x860)) {
             return cPhs_ERROR_e;
         } else if (!Create()) {
             return cPhs_ERROR_e;

src/d/actor/d_a_obj_kamakiri.cpp

@@ -517,7 +517,13 @@ void daObjKAM_c::Z_BufferChk() {
     cXyz currentOffset;
     currentOffset = current.pos;
     currentOffset.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&currentOffset, &currentProj, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&currentOffset, &currentProj);
+    #endif
+
     camera_process_class* camera = dComIfGp_getCamera(0);
     f32 cameraHeight;
     if (camera != NULL) {

src/d/actor/d_a_obj_katatsumuri.cpp

@@ -611,7 +611,12 @@ void daObjKAT_c::Z_BufferChk() {
     cXyz curWithOff;
     curWithOff = current.pos;
     curWithOff.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&curWithOff, &projected, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&curWithOff, &projected);
+    #endif
 
     camera_process_class* camera = dComIfGp_getCamera(0);
     f32 unkFloat1;

src/d/actor/d_a_obj_kuwagata.cpp

@@ -528,7 +528,12 @@ void daObjKUW_c::Z_BufferChk() {
 
     cStack_68 = current.pos;
     cStack_68.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&cStack_68, &local_5c, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&cStack_68, &local_5c);
+    #endif
     
     camera_process_class* cc = dComIfGp_getCamera(0);
     f32 trimHeight;

src/d/actor/d_a_obj_lv3Water.cpp

@@ -371,8 +371,14 @@ int daLv3Water_c::Draw() {
             texMtxInfo = &material->getTexGenBlock()->getTexMtx(0)->getTexMtxInfo();
             if (texMtxInfo != NULL) {
                 Mtx lightProjMtx;
+
+                #if TARGET_PC
+                C_MTXLightPerspective(lightProjMtx, dComIfGd_getView()->fovy,
+                                      dComIfGd_getView()->aspect, 1.0f, 1.0f, dusk::getSettings().game.useWaterProjectionOffset ? -0.01f : 0.0f, 0.0f);
+                #else
                 C_MTXLightPerspective(lightProjMtx, dComIfGd_getView()->fovy,
                                       dComIfGd_getView()->aspect, 1.0f, 1.0f, -0.01f, 0.0f);
+                #endif
 
                 #if WIDESCREEN_SUPPORT
                 mDoGph_gInf_c::setWideZoomLightProjection(lightProjMtx);

src/d/actor/d_a_obj_lv3Water2.cpp

@@ -197,7 +197,13 @@ int daLv3Water2_c::Draw() {
         texMtxInfo = &btkMaterial->getTexGenBlock()->getTexMtx(0)->getTexMtxInfo();
         if(texMtxInfo) {
             Mtx lightProjMtx;
+
+            #if TARGET_PC
+            C_MTXLightPerspective(lightProjMtx, dComIfGd_getView()->fovy,
+                                  dComIfGd_getView()->aspect, 1.0f, 1.0f, dusk::getSettings().game.useWaterProjectionOffset ? -0.01f : 0.0f, 0);
+            #else
             C_MTXLightPerspective(lightProjMtx, dComIfGd_getView()->fovy, dComIfGd_getView()->aspect, 1.0f, 1.0f, -0.01f, 0);
+            #endif
 
             #if WIDESCREEN_SUPPORT
             mDoGph_gInf_c::setWideZoomLightProjection(lightProjMtx);

src/d/actor/d_a_obj_lv3WaterB.cpp

@@ -27,8 +27,15 @@ static int daObj_Lv3waterB_Draw(obj_lv3WaterB_class* i_this) {
         J3DTexMtxInfo* tex_mtx_info = &material_p->getTexGenBlock()->getTexMtx(0)->getTexMtxInfo();
         if (tex_mtx_info != NULL) {
             Mtx m;
+
+            #if TARGET_PC
+            C_MTXLightPerspective(m, dComIfGd_getView()->fovy, dComIfGd_getView()->aspect, 1.0f, 1.0f,
+                dusk::getSettings().game.useWaterProjectionOffset ? -0.015f : 0.0f, 0.0f);
+            #else
             C_MTXLightPerspective(m, dComIfGd_getView()->fovy, dComIfGd_getView()->aspect, 1.0f,
                                   1.0f, -0.015f, 0.0f);
+            #endif
+
             #if WIDESCREEN_SUPPORT
             mDoGph_gInf_c::setWideZoomLightProjection(m);
             #endif

src/d/actor/d_a_obj_rstair.cpp

@@ -313,8 +313,15 @@ int daObjRotStair_c::Draw() {
             J3DTexMtxInfo* texMtxInfo = &material->getTexGenBlock()->getTexMtx(0)->getTexMtxInfo();
             if (texMtxInfo != NULL) {
                 Mtx lightMtx;
+
+                #if TARGET_PC
+                C_MTXLightPerspective(lightMtx, dComIfGd_getView()->fovy,
+                                      dComIfGd_getView()->aspect, 1.0f, 1.0f, dusk::getSettings().game.useWaterProjectionOffset ? -0.01f : 0.0f, 0);
+                #else
                 C_MTXLightPerspective(lightMtx, dComIfGd_getView()->fovy,
                                       dComIfGd_getView()->aspect, 1.0f, 1.0f, -0.01f, 0);
+                #endif
+
                 #if WIDESCREEN_SUPPORT
                 mDoGph_gInf_c::setWideZoomLightProjection(lightMtx);
                 #endif

src/d/actor/d_a_obj_stick.cpp

@@ -198,24 +198,24 @@ void daObj_Stick_c::setMtx() {
     mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
 }
 
-static u32 daObj_Stick_Create(void* i_this) {
+static int daObj_Stick_Create(void* i_this) {
     return static_cast<daObj_Stick_c*>(i_this)->create();
 }
 
-static void daObj_Stick_Delete(void* param_0) {
-    static_cast<daObj_Stick_c*>(param_0)->Delete();
+static int daObj_Stick_Delete(void* param_0) {
+    return static_cast<daObj_Stick_c*>(param_0)->Delete();
 }
 
-static void daObj_Stick_Execute(void* param_0) {
-    static_cast<daObj_Stick_c*>(param_0)->Execute();
+static int daObj_Stick_Execute(void* param_0) {
+    return static_cast<daObj_Stick_c*>(param_0)->Execute();
 }
 
-static void daObj_Stick_Draw(void* param_0) {
-    static_cast<daObj_Stick_c*>(param_0)->Draw();
+static int daObj_Stick_Draw(void* param_0) {
+    return static_cast<daObj_Stick_c*>(param_0)->Draw();
 }
 
-static BOOL daObj_Stick_IsDelete(void* param_0) {
-    return TRUE;
+static int daObj_Stick_IsDelete(void* param_0) {
+    return 1;
 }
 
 static actor_method_class daObj_Stick_MethodTable = {

src/d/actor/d_a_obj_stone.cpp

@@ -126,7 +126,7 @@ static f32 bound(cXyz* param_0, cBgS_PolyInfo const& param_1, f32 param_2) {
         cXyz pos;
         f32 abs = param_0->abs();
 
-        C_VECReflect(param_0, (Vec*)&plane, &pos);
+        C_VECReflect(param_0, &plane.mNormal, &pos);
         *param_0 = pos * abs * param_2;
 
         return param_0->absXZ();

src/d/actor/d_a_obj_ten.cpp

@@ -593,7 +593,13 @@ void daObjTEN_c::Z_BufferChk() {
     cXyz cStack_68;
     cStack_68 = current.pos;
     cStack_68.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&cStack_68, &local_5c, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&cStack_68, &local_5c);
+    #endif
+
     camera_process_class* camera = dComIfGp_getCamera(0);
     f32 trimHeight;
     if (camera != NULL) {

src/d/actor/d_a_obj_tombo.cpp

@@ -504,7 +504,13 @@ void daObjTOMBO_c::Z_BufferChk() {
     cXyz cStack_68;
     cStack_68 = current.pos;
     cStack_68.y += 20.0f;
+
+    #if TARGET_PC
+    mDoLib_project(&cStack_68, &local_5c, {0, 0, FB_WIDTH, FB_HEIGHT});
+    #else
     mDoLib_project(&cStack_68, &local_5c);
+    #endif
+
     camera_process_class* pCamera = dComIfGp_getCamera(0);
     f32 trimHeight;
     if (pCamera != NULL) {

src/d/actor/d_a_obj_tp.cpp

@@ -36,8 +36,15 @@ static int daObj_Tp_Draw(obj_tp_class* i_this) {
                         &material->getTexGenBlock()->getTexMtx(0)->getTexMtxInfo();
                     if (texMtxInfo != NULL) {
                         Mtx lightProjMtx;
+
+                        #if TARGET_PC
+                        C_MTXLightPerspective(lightProjMtx, dComIfGd_getView()->fovy,
+                                              dComIfGd_getView()->aspect, 1.0f, 1.0f, dusk::getSettings().game.useWaterProjectionOffset ? -0.01f : 0.0f, 0);
+                        #else
                         C_MTXLightPerspective(lightProjMtx, dComIfGd_getView()->fovy,
                                               dComIfGd_getView()->aspect, 1.0f, 1.0f, -0.01f, 0);
+                        #endif
+
                         #if WIDESCREEN_SUPPORT
                         mDoGph_gInf_c::setWideZoomLightProjection(lightProjMtx);
                         #endif

src/d/actor/d_a_obj_zra_freeze.cpp

@@ -38,7 +38,12 @@ BOOL daZraFreeze_c::chkActorInScreen() {
     mDoMtx_stack_c::transM(0.0f, 0.0f, 0.0f);
     PSMTXMultVecArray(mDoMtx_stack_c::get(), vec, vec, 8);
     for (int i = 0; i < 8; i++) {
+        #if TARGET_PC
+        mDoLib_project(&vec[i], &proj, {0, 0, FB_WIDTH, FB_HEIGHT});
+        #else
         mDoLib_project(&vec[i], &proj);
+        #endif
+
         if (0.0f < proj.x && proj.x < FB_WIDTH && 0.0f < proj.y && proj.y < FB_HEIGHT) {
             continue;
         }

src/d/actor/d_a_peru.cpp

@@ -59,7 +59,7 @@ static daNpcT_motionAnmData_c l_motionAnmData[11] = {
 static daNpcT_MotionSeqMngr_c::sequenceStepData_c l_faceMotionSequenceData[20] = {
     {1, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {2, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {3, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
-    {4, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
+    {4, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, 
 };
 
 static daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenceData[40] = {

src/d/actor/d_a_player.cpp

@@ -237,11 +237,7 @@ void* daPy_anmHeap_c::mallocBuffer() {
     return mBuffer;
 }
 
-#if TARGET_PC
 void daPy_anmHeap_c::createHeap(daPy_anmHeap_c::daAlinkHEAP_TYPE i_heapType, const char* name) {
-#else
-void daPy_anmHeap_c::createHeap(daPy_anmHeap_c::daAlinkHEAP_TYPE i_heapType, const char* name) {
-#endif
     u32 size;
 
     if (i_heapType == 4) {
@@ -255,6 +251,9 @@ void daPy_anmHeap_c::createHeap(daPy_anmHeap_c::daAlinkHEAP_TYPE i_heapType, con
     } else {
         size = 0xA0;
     }
+#if TARGET_PC
+    size *= 2;
+#endif
 
     char* tmpWork;
     mDoExt_transAnmBas* tmpTransBas;
@@ -368,7 +367,30 @@ JKRHeap* daPy_anmHeap_c::setAnimeHeap() {
 }
 
 #if !PLATFORM_WII
+#if TARGET_PC
+#include "dusk/dvd_asset.hpp"
+static const u8* l_sightDL_get() { 
+    static u8 buf[0x89];
+    static bool _ = (
+        dusk::LoadDolAsset(
+            buf,
+            #if VERSION == VERSION_GCN_PAL
+            0x803BBDA0,
+            #elif VERSION == VERSION_GCN_JPN
+            0x803B4220,
+            #elif VERSION == VERSION_GCN_USA
+            0x803BA0C0,
+            #endif
+            0x89
+        ),
+        true
+    );
+    return buf;
+}
+#define l_sightDL (l_sightDL_get())
+#else
 #include "assets/l_sightDL__d_a_player.h"
+#endif
 
 void daPy_sightPacket_c::draw() {
     TGXTexObj texObj;

src/d/actor/d_a_tag_magne.cpp

@@ -44,15 +44,15 @@ int daTagMagne_c::_delete() {
     return 1;
 }
 
-static void daTagMagne_Delete(daTagMagne_c* i_this) {
+static int daTagMagne_Delete(daTagMagne_c* i_this) {
     int id = fopAcM_GetID(i_this);
-    i_this->_delete();
+    return i_this->_delete();
 }
 
-static void daTagMagne_Create(fopAc_ac_c* i_this) {
+static int daTagMagne_Create(fopAc_ac_c* i_this) {
     daTagMagne_c* magne = static_cast<daTagMagne_c*>(i_this);
     int id = fopAcM_GetID(i_this);
-    magne->create();
+    return magne->create();
 }
 
 static actor_method_class l_daTagMagne_Method = {

src/d/actor/d_a_tag_sppath.cpp

@@ -189,7 +189,7 @@ int daTagSppath_c::execute() {
     }
 
     if (mpBestPath->field_0x4 == 0) {
-        if (mpBestPath->field_0x6 == 0xff || fopAcM_isSwitch(this, mpBestPath->field_0x6) == 0) {
+        if (mpBestPath->swbit == 0xff || fopAcM_isSwitch(this, mpBestPath->swbit) == 0) {
             field_0x6e8 = 1;
         } else {
             field_0x6e8 = 2;

src/d/actor/d_a_tbox.cpp

@@ -650,7 +650,7 @@ void daTbox_c::dropProcInit() {
         field_0x97c = false;
 
         f32 delta_y = pos.y - pnt1.y;
-        f32 abs_gravity = std::fabsf(fopAcM_GetGravity(this));
+        f32 abs_gravity = fabsf(fopAcM_GetGravity(this));
 
         var_f30 = JMAFastSqrt(2.0f * delta_y / abs_gravity);
         speedF = pos.absXZ(pnt1) / var_f30;

src/d/actor/d_flower.inc

@@ -5,9 +5,21 @@
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
 #include "SSystem/SComponent/c_counter.h"
 
+#if TARGET_PC
+const u16 l_J_Ohana00_64TEX__width = 64;
+const u16 l_J_Ohana00_64TEX__height = 64;
+#else
 const u16 l_J_Ohana00_64TEX__width = 63;
 const u16 l_J_Ohana00_64TEX__height = 63;
+#endif
+
+#if TARGET_PC
+#include "dusk/dvd_asset.hpp"
+static u8* l_J_Ohana00_64TEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9060, 0x800), true); return buf; }
+#define l_J_Ohana00_64TEX (l_J_Ohana00_64TEX_get())
+#else
 #include "assets/l_J_Ohana00_64TEX.h"
+#endif
 
 static u8 l_flowerPos[708] = {
     0xC0, 0x8C, 0x2C, 0xF7, 0x42, 0x05, 0xBC, 0xDF, 0xC1, 0xA1, 0x00, 0x70, 0xBF, 0x50, 0x51, 0xB9,
@@ -72,8 +84,8 @@ static u8 l_flowerNormal[180] = {
     0x46, 0x54, 0x0D, 0x3C, 0x4B, 0xEE, 0x80, 0x3F, 0x7F, 0xF5, 0xF9, 0x3C, 0x49, 0x81, 0xBF,
 };
 
-static u8 l_flowerColor[8] = {
-    0xFF, 0xFF, 0xFF, 0xFF, 0xB2, 0xB2, 0xB2, 0xFF,
+static GXColor l_flowerColor[2] = {
+    {0xFF, 0xFF, 0xFF, 0xFF}, {0xB2, 0xB2, 0xB2, 0xFF}
 };
 
 static u8 l_flowerTexCoord[] = {
@@ -98,6 +110,16 @@ static u8 l_flowerTexCoord[] = {
     0x3E, 0xA7, 0x67, 0x4D, 0x3C, 0x14, 0x46, 0x74, 0x3E, 0xA7, 0x73, 0xE2, 0xBC, 0x2F, 0x46, 0xAA,
     0x3E, 0xA7, 0x72, 0xD6, 0xBD, 0x2F, 0x46, 0xAA};
 
+#if TARGET_PC
+static u8* l_J_hana00DL_get()   { static u8 buf[0x150]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9D20, 0x150), true); return buf; }
+static u8* l_J_hana00_cDL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9E80, 0xDE),  true); return buf; }
+static u8* l_matDL_get()        { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x9F60, 0x99),  true); return buf; }
+static u8* l_matLight4DL_get()  { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xA000, 0x99),  true); return buf; }
+#define l_J_hana00DL   (l_J_hana00DL_get())
+#define l_J_hana00_cDL (l_J_hana00_cDL_get())
+#define l_matDL        (l_matDL_get())
+#define l_matLight4DL  (l_matLight4DL_get())
+#else
 #include "assets/l_J_hana00DL.h"
 
 #include "assets/l_J_hana00_cDL.h"
@@ -107,10 +129,22 @@ l_matDL__d_a_grass(l_J_Ohana00_64TEX)
 
 #include "assets/l_matLight4DL.h"
 l_matLight4DL(l_J_Ohana00_64TEX)
+#endif
 
+#if TARGET_PC
+const u16 l_J_Ohana01_64128_0419TEX__width = 64;
+const u16 l_J_Ohana01_64128_0419TEX__height = 128;
+#else
 const u16 l_J_Ohana01_64128_0419TEX__width = 63;
 const u16 l_J_Ohana01_64128_0419TEX__height = 127;
+#endif
+
+#if TARGET_PC
+static u8* l_J_Ohana01_64128_0419TEX_get() { static u8 buf[0x1000]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xA0A0, 0x1000), true); return buf; }
+#define l_J_Ohana01_64128_0419TEX (l_J_Ohana01_64128_0419TEX_get())
+#else
 #include "assets/l_J_Ohana01_64128_0419TEX.h"
+#endif
 
 static u8 l_flowerPos2[1224] = {
     0x40, 0x25, 0x9F, 0x34, 0x42, 0xC2, 0x95, 0x72, 0xC1, 0x22, 0x34, 0x78, 0x41, 0x4D, 0xF9, 0x63,
@@ -213,8 +247,8 @@ static u8 l_flowerNormal2[288] = {
     0x3B, 0x76, 0x7B, 0x1C, 0x3B, 0x99, 0x6B, 0x76, 0x3F, 0x7F, 0xF5, 0xF9, 0xBC, 0x8A, 0x1D, 0xFC,
 };
 
-static u8 l_flowerColor2[8] = {
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xB2, 0xFF,
+static GXColor l_flowerColor2[2] = {
+    {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xB2, 0xFF}
 };
 
 static u8 l_flowerTexCoord2[] = {
@@ -237,6 +271,18 @@ static u8 l_flowerTexCoord2[] = {
     0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x97, 0xF6, 0xBA, 0x40, 0x04, 0x26, 0x74, 0x3F, 0x80, 0x3F, 0x79,
     0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x80, 0x3F, 0x79, 0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x51, 0x10, 0x6F};
 
+#if TARGET_PC
+static u8* l_J_hana01DL_get()      { static u8 buf[0x138]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xB7C0, 0x138), true); return buf; }
+static u8* l_J_hana01_c_00DL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xB900, 0xDE),  true); return buf; }
+static u8* l_J_hana01_c_01DL_get() { static u8 buf[0x128]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xB9E0, 0x128), true); return buf; }
+static u8* l_mat2DL_get()          { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xBB20, 0x99),  true); return buf; }
+static u8* l_mat2Light4DL_get()    { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0xBBC0, 0x99),  true); return buf; }
+#define l_J_hana01DL      (l_J_hana01DL_get())
+#define l_J_hana01_c_00DL (l_J_hana01_c_00DL_get())
+#define l_J_hana01_c_01DL (l_J_hana01_c_01DL_get())
+#define l_mat2DL          (l_mat2DL_get())
+#define l_mat2Light4DL    (l_mat2Light4DL_get())
+#else
 #include "assets/l_J_hana01DL.h"
 
 #include "assets/l_J_hana01_c_00DL.h"
@@ -248,6 +294,7 @@ l_mat2DL__d_a_grass(l_J_Ohana01_64128_0419TEX)
 
 #include "assets/l_mat2Light4DL.h"
 l_mat2Light4DL(l_J_Ohana01_64128_0419TEX)
+#endif
 
 void dFlower_data_c::WorkCo(fopAc_ac_c* i_hitActor, u32 i_massFlg, int i_roomNo) {
     cXyz sp8;
@@ -509,6 +556,42 @@ dFlower_packet_c::dFlower_packet_c() {
         unused += 0x2000;
     }
 
+#if TARGET_LITTLE_ENDIAN
+    static bool initialized = false;
+    if (!initialized) {
+        for (int i = 0; i < (ARRAY_SIZE(l_flowerPos) / sizeof(Vec)); i++) {
+            be_swap(((Vec*)l_flowerPos)[i]);
+        }
+        for (int i = 0; i < (ARRAY_SIZE(l_flowerTexCoord) / sizeof(Vec)); i++) {
+            be_swap(((Vec*)l_flowerTexCoord)[i]);
+        }
+        for (int i = 0; i < (ARRAY_SIZE(l_flowerPos2) / sizeof(Vec)); i++) {
+            be_swap(((Vec*)l_flowerPos2)[i]);
+        }
+        for (int i = 0; i < (ARRAY_SIZE(l_flowerTexCoord2) / sizeof(Vec)); i++) {
+            be_swap(((Vec*)l_flowerTexCoord2)[i]);
+        }
+        for (int i = 0; i < (ARRAY_SIZE(l_flowerNormal) / sizeof(Vec)); i++) {
+            be_swap(((Vec*)l_flowerNormal)[i]);
+        }
+        for (int i = 0; i < (ARRAY_SIZE(l_flowerNormal2) / sizeof(Vec)); i++) {
+            be_swap(((Vec*)l_flowerNormal2)[i]);
+        }
+        
+        initialized = true;
+    }
+#endif
+
+#if TARGET_PC
+    GXInitTexObj(&mTexObj_l_J_Ohana00_64TEX, l_J_Ohana00_64TEX,
+        l_J_Ohana00_64TEX__width, l_J_Ohana00_64TEX__height, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
+    );
+
+    GXInitTexObj(&mTexObj_l_J_Ohana01_64128_0419TEX, l_J_Ohana01_64128_0419TEX,
+        l_J_Ohana01_64128_0419TEX__width, l_J_Ohana01_64128_0419TEX__height, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
+    );
+#endif
+
     m_deleteRoom = &dFlower_packet_c::deleteRoom;
 
 #if AVOID_UB
@@ -531,10 +614,10 @@ void dFlower_packet_c::draw() {
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_NRM_XYZ, GX_F32, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
-    GXSETARRAY(GX_VA_POS, &l_flowerPos, sizeof(l_flowerPos), 0xC);
-    GXSETARRAY(GX_VA_NRM, &l_flowerNormal, sizeof(l_flowerNormal), 0xC);
-    GXSETARRAY(GX_VA_CLR0, &l_flowerColor, sizeof(l_flowerColor), 4);
-    GXSETARRAY(GX_VA_TEX0, &l_flowerTexCoord, sizeof(l_flowerTexCoord), 8);
+    GXSETARRAY(GX_VA_POS, &l_flowerPos, sizeof(l_flowerPos), sizeof(Vec), true);
+    GXSETARRAY(GX_VA_NRM, &l_flowerNormal, sizeof(l_flowerNormal), sizeof(Vec), true);
+    GXSETARRAY(GX_VA_CLR0, &l_flowerColor, sizeof(l_flowerColor), sizeof(GXColor), true);
+    GXSETARRAY(GX_VA_TEX0, &l_flowerTexCoord, sizeof(l_flowerTexCoord), 8, true);
 
     GXColor sp64;
     dFlower_room_c* sp5C = m_room;
@@ -562,9 +645,9 @@ void dFlower_packet_c::draw() {
             }
 
             if (sp4C <= 2) {
-                GXCallDisplayList(&l_matLight4DL, 0x80);
+                GXCallDisplayList(l_matLight4DL, 0x80);
             } else {
-                GXCallDisplayList(&l_matDL, 0x80);
+                GXCallDisplayList(l_matDL, 0x80);
             }
 
             GXSetTevColorS10(GX_TEVREG0, sp80);
@@ -615,10 +698,14 @@ void dFlower_packet_c::draw() {
                     GXLoadPosMtxImm(sp44->m_modelMtx, 0);
                     GXLoadNrmMtxImm(j3dSys.getViewMtx(), 0);
 
+#if TARGET_PC
+                GXLoadTexObj(&mTexObj_l_J_Ohana00_64TEX, GX_TEXMAP0);
+#endif
+
                     if (!cLib_checkBit<u8>(sp44->m_state, 8)) {
-                        GXCallDisplayList(&l_J_hana00DL, 0x140);
+                        GXCallDisplayList(l_J_hana00DL, 0x140);
                     } else {
-                        GXCallDisplayList(&l_J_hana00_cDL, 0xC0);
+                        GXCallDisplayList(l_J_hana00_cDL, 0xC0);
                     }
                 }
             }
@@ -626,10 +713,10 @@ void dFlower_packet_c::draw() {
         sp5C++;
     }
 
-    GXSETARRAY(GX_VA_POS, mp_pos, sizeof(l_flowerPos2), 0xC);
-    GXSETARRAY(GX_VA_NRM, &l_flowerNormal2, sizeof(l_flowerNormal2), 0xC);
-    GXSETARRAY(GX_VA_CLR0, mp_colors, sizeof(l_flowerColor2), 4);
-    GXSETARRAY(GX_VA_TEX0, mp_texCoords, sizeof(l_flowerTexCoord2), 8);
+    GXSETARRAY(GX_VA_POS, mp_pos, sizeof(l_flowerPos2), sizeof(Vec), true);
+    GXSETARRAY(GX_VA_NRM, &l_flowerNormal2, sizeof(l_flowerNormal2), sizeof(Vec), true);
+    GXSETARRAY(GX_VA_CLR0, mp_colors, sizeof(l_flowerColor2), sizeof(GXColor), true);
+    GXSETARRAY(GX_VA_TEX0, mp_texCoords, sizeof(l_flowerTexCoord2), 8, true);
 
     sp5C = m_room;
 
@@ -757,11 +844,15 @@ void dFlower_packet_c::draw() {
                     GXLoadPosMtxImm(sp34->m_modelMtx, 0);
                     GXLoadNrmMtxImm(j3dSys.getViewMtx(), 0);
 
+#if TARGET_PC
+                    GXLoadTexObj(&mTexObj_l_J_Ohana01_64128_0419TEX, GX_TEXMAP0);
+#endif
+
                     if (!cLib_checkBit<u8>(sp34->m_state, 8)) {
                         if (!cLib_checkBit<u8>(sp34->m_state, 0x10)) {
                             GXCallDisplayList(mp_Jhana01DL, m_Jhana01DL_size);
                         } else {
-                            GXCallDisplayList(&l_J_hana01_c_00DL, 0xC0);
+                            GXCallDisplayList(l_J_hana01_c_00DL, 0xC0);
                         }
                     } else {
                         GXCallDisplayList(mp_Jhana01_cDL, m_Jhana01_cDL_size);

src/d/actor/d_grass.inc

@@ -13,11 +13,19 @@
 
 const u16 l_M_Hijiki00TEX__width = 31;
 const u16 l_M_Hijiki00TEX__height = 31;
-#include "assets/l_M_kusa05_RGBATEX.h"  // ALIGN 32
-
 const u16 l_M_kusa05_RGBATEX__width = 31;
 const u16 l_M_kusa05_RGBATEX__height = 31;
-#include "assets/l_M_Hijiki00TEX.h"  // ALIGN 32
+
+#if TARGET_PC
+#include "dusk/dvd_asset.hpp"
+static u8* l_M_kusa05_RGBATEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x7680, 0x800), true); return buf; }
+static u8* l_M_Hijiki00TEX_get()    { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x7E80, 0x800), true); return buf; }
+#define l_M_kusa05_RGBATEX (l_M_kusa05_RGBATEX_get())
+#define l_M_Hijiki00TEX    (l_M_Hijiki00TEX_get())
+#else
+#include "assets/l_M_kusa05_RGBATEX.h"  // ALIGN 32
+#include "assets/l_M_Hijiki00TEX.h"     // ALIGN 32
+#endif
 
 static u8 l_pos[960] = {
     0x3F, 0x4A, 0x56, 0xEF, 0xC2, 0x20, 0x00, 0x00, 0x41, 0xFB, 0x17, 0xE4, 0x41, 0xAA, 0xBB, 0xEA,
@@ -102,6 +110,20 @@ static u8 l_texCoord[160] = {
     0x3F, 0x94, 0x00, 0x00, 0x3F, 0x80, 0x00, 0x00, 0xBD, 0xC0, 0x00, 0x00, 0x3F, 0x80, 0x00, 0x00,
 };
 
+#if TARGET_PC
+static u8* l_M_Kusa_9qDL_get()     { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8B00, 0xCB),  true); return buf; }
+static u8* l_M_Kusa_9q_cDL_get()   { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8BE0, 0xCB),  true); return buf; }
+static u8* l_M_TenGusaDL_get()     { static u8 buf[0xD4]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8CC0, 0xD4),  true); return buf; }
+static u8* l_Tengusa_matDL_get()   { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8DA0, 0xA8),  true); return buf; }
+static u8* l_kusa9q_matDL_get()    { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8E60, 0xA8),  true); return buf; }
+static u8* l_kusa9q_l4_matDL_get() { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", 0x8F20, 0xA8),  true); return buf; }
+#define l_M_Kusa_9qDL     (l_M_Kusa_9qDL_get())
+#define l_M_Kusa_9q_cDL   (l_M_Kusa_9q_cDL_get())
+#define l_M_TenGusaDL     (l_M_TenGusaDL_get())
+#define l_Tengusa_matDL   (l_Tengusa_matDL_get())
+#define l_kusa9q_matDL    (l_kusa9q_matDL_get())
+#define l_kusa9q_l4_matDL (l_kusa9q_l4_matDL_get())
+#else
 #include "assets/l_M_Kusa_9qDL.h"
 
 #include "assets/l_M_Kusa_9q_cDL.h"
@@ -117,6 +139,7 @@ l_kusa9q_matDL(l_M_kusa05_RGBATEX)
 
 #include "assets/l_kusa9q_l4_matDL.h"
 l_kusa9q_l4_matDL(l_M_kusa05_RGBATEX)
+#endif
 
 void dGrass_data_c::WorkCo(fopAc_ac_c* i_hitActor, u32 i_massFlg, int i_roomNo) {
     cXyz sp18;
@@ -536,10 +559,10 @@ void dGrass_packet_c::draw() {
 
     GXSetVtxDescv(l_vtxDescList);
     GXSetVtxAttrFmtv(GX_VTXFMT0, l_vtxAttrFmtList);
-    GXSETARRAY(GX_VA_POS, mp_pos, sizeof(l_pos), sizeof(Vec));
-    GXSETARRAY(GX_VA_NRM, mp_normal, sizeof(l_normal), sizeof(Vec));
-    GXSETARRAY(GX_VA_CLR0, mp_colors, sizeof(l_color), sizeof(GXColor));
-    GXSETARRAY(GX_VA_TEX0, mp_texCoords, sizeof(l_texCoord), 8);
+    GXSETARRAY(GX_VA_POS, mp_pos, sizeof(l_pos), sizeof(Vec), true);
+    GXSETARRAY(GX_VA_NRM, mp_normal, sizeof(l_normal), sizeof(Vec), true);
+    GXSETARRAY(GX_VA_CLR0, mp_colors, sizeof(l_color), sizeof(GXColor), true);
+    GXSETARRAY(GX_VA_TEX0, mp_texCoords, sizeof(l_texCoord), 8, true);
 
     GXColorS10 spA0 = {0, 0, 0, 0};
     GXColorS10 sp98 = {0, 0, 0, 0};

src/d/d_bg_parts.cpp

@@ -106,7 +106,7 @@ void dBgp_c::modelMaterial_c::set(J3DModelData* i_modelData, J3DMaterial* i_mate
 void dBgp_c::model_c::create(J3DModelData* i_modelData, Mtx i_mtx) {
     const void* binary = i_modelData->getBinary();
 
-    mId = *(u32*)((char*)binary + 0x1C);
+    mId = *(BE(u32)*)((char*)binary + 0x1C);
     if (mId != 0xFFFF) {
         addShare(mId);
     }

src/d/d_bg_s.cpp

@@ -10,12 +10,14 @@
 #include "d/d_bg_w.h"
 #include "d/d_com_inf_game.h"
 #include "f_op/f_op_actor_mng.h"
-#include "dusk/offset_ptr.h"
 
 #include "d/d_debug_viewer.h"
 #include "d/d_bg_s_capt_poly.h"
 
-#include "dusk/imgui/ImGuiConsole.hpp"
+#if TARGET_PC
+#include "dusk/offset_ptr.h"
+#include "dusk/settings.h"
+#endif
 
 #if DEBUG
 int g_ground_counter;
@@ -619,8 +621,8 @@ static int poly_draw(dBgS_CaptPoly* capt, cBgD_Vtx_t* vtxList, int v0, int v1, i
     GXColor wall_color = {0, 0xFF, 0, 0xFF};
 
 #if TARGET_PC
-    dusk::ImGuiMenuTools::CollisionViewSettings collisionViewSettings = dusk::g_imguiConsole.getCollisionViewSettings();
-    f32 view_opacity = 255 * (collisionViewSettings.m_terrainViewOpacity / 100.0f);
+    const auto& collisionViewSettings = dusk::getTransientSettings().collisionView;
+    f32 view_opacity = 255 * (collisionViewSettings.terrainViewOpacity / 100.0f);
     ground_color.a = view_opacity;
     roof_color.a = view_opacity;
     wall_color.a = view_opacity;
@@ -658,16 +660,16 @@ void dBgS::Draw() {
     cBgS::Draw();
 
 #if TARGET_PC
-    #define IMGUI_TOGGLE_HIO_FLAG(status, flag) \
+    #define DUSK_TOGGLE_HIO_FLAG(status, flag) \
         if (status) { \
             s_InsideHio.m_flags |= flag; \
         } else { \
             s_InsideHio.m_flags &= ~flag; \
         }
 
-    dusk::ImGuiMenuTools::CollisionViewSettings collisionViewSettings = dusk::g_imguiConsole.getCollisionViewSettings();
-    IMGUI_TOGGLE_HIO_FLAG(collisionViewSettings.m_enableTerrainView, dBgS_InsideHIO::FLAG_DISP_POLY_e);
-    IMGUI_TOGGLE_HIO_FLAG(collisionViewSettings.m_enableWireframe, dBgS_InsideHIO::FLAG_WHITE_WIRE_e);
+    const auto& collisionViewSettings = dusk::getTransientSettings().collisionView;
+    DUSK_TOGGLE_HIO_FLAG(collisionViewSettings.enableTerrainView, dBgS_InsideHIO::FLAG_DISP_POLY_e);
+    DUSK_TOGGLE_HIO_FLAG(collisionViewSettings.enableWireframe, dBgS_InsideHIO::FLAG_WHITE_WIRE_e);
 #endif
 
     if (s_InsideHio.ChkDispPoly()) {
@@ -680,8 +682,7 @@ void dBgS::Draw() {
             f32 var_f31 = fabsf(s_InsideHio.m_p0.x);
 
 #if TARGET_PC
-            dusk::ImGuiMenuTools::CollisionViewSettings collisionViewSettings = dusk::g_imguiConsole.getCollisionViewSettings();
-            var_f31 = collisionViewSettings.m_drawRange;
+            var_f31 = collisionViewSettings.drawRange;
 #endif
 
             min.x = player->current.pos.x - var_f31;

src/d/d_bright_check.cpp

@@ -143,7 +143,56 @@ void dBrightCheck_c::modeMove() {
     }
 }
 
+#if TARGET_PC
+void dBrightCheck_c::brightCheckWide() {
+    // Main Canvas
+    mBrightCheck.Scr->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mBrightCheck.Scr->translate(mDoGph_gInf_c::getMinXF(), 0.0f);
+
+    // Right Square
+    mBrightCheck.Scr->search(MULTI_CHAR('fuchi_1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('big_squa'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Middle Square
+    mBrightCheck.Scr->search(MULTI_CHAR('fuchi_3'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('big_squ1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Left Square
+    mBrightCheck.Scr->search(MULTI_CHAR('fuchi_4'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('big_squ2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Gray Squares
+    mBrightCheck.Scr->search(MULTI_CHAR('gray_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('fuchi_2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Confirm A Button
+    mBrightCheck.Scr->search(MULTI_CHAR('abtn_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('gcabtn_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Text
+    mBrightCheck.Scr->search(MULTI_CHAR('menu_6n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('menu_9n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('menu_10n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('menu_7n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('menu_8n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('fmenu_8n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('fmenu_7n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('fmenu_10'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('fmenu_6n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('fmenu_9n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('t_t00'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('f_t00'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Spirals
+    mBrightCheck.Scr->search(MULTI_CHAR('t_mo_l_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mBrightCheck.Scr->search(MULTI_CHAR('t_mo_r_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+}
+#endif
+
 void dBrightCheck_c::_draw() {
+    #if TARGET_PC
+    brightCheckWide();
+    #endif
     dComIfGd_set2DOpa(&mBrightCheck);
 }
 

src/d/d_camera.cpp

@@ -762,6 +762,13 @@ void dCamera_c::updatePad() {
         var_f29 = 0.0f;
     } else {
         var_f31 = mDoCPd_c::getSubStickX3D(mPadID);
+
+        #if TARGET_PC
+        if (dusk::getSettings().game.invertCameraXAxis) {
+            var_f31 *= -1.0f;
+        }
+        #endif
+
         var_f30 = mDoCPd_c::getSubStickY(mPadID);
         var_f29 = mDoCPd_c::getSubStickValue(mPadID);
     }
@@ -2410,10 +2417,18 @@ f32 dCamera_c::radiusActorInSight(fopAc_ac_c* i_actor1, fopAc_ac_c* i_actor2, cX
     dDlst_window_c* window = get_window(field_0x0);
     scissor_class* scissor = window->getScissor();
     f32 var_f29 = cAngle::d2r(i_fovY) * 0.5f;
+#if TARGET_PC
+    view_port_class* viewport = window->getViewPort();
+    f32 var_f28 = (scissor->height - mTrimHeight * 2.0f) / viewport->height;
+    f32 sp34 = var_f29 * var_f28 * (mTrimHeight < 0.01f ? 0.95f : 1.0f);
+    var_f29 *= mWindowAspect;
+    var_f28 = scissor->width / viewport->width;
+#else
     f32 var_f28 = (scissor->height - mTrimHeight * 2.0f) / FB_HEIGHT;
     f32 sp34 = var_f29 * var_f28 * (mTrimHeight < 0.01f ? 0.95f : 1.0f);
     var_f29 *= mWindowAspect;
     var_f28 = scissor->width / FB_WIDTH;
+#endif
     f32 sp30 = var_f29 * var_f28 * 0.85f;
 
     cXyz pos1 = attentionPos(i_actor1);
@@ -2443,8 +2458,8 @@ f32 dCamera_c::radiusActorInSight(fopAc_ac_c* i_actor1, fopAc_ac_c* i_actor2, cX
 
     int bVar2 = 0;
 
-    var_f29 = std::fabsf(cM_atan2f(pos1.x, -pos1.z));
-    var_f28 = std::fabsf(cM_atan2f(pos1.y, -pos1.z));
+    var_f29 = fabsf(cM_atan2f(pos1.x, -pos1.z));
+    var_f28 = fabsf(cM_atan2f(pos1.y, -pos1.z));
     if (var_f29 > sp30) {
         bVar2 |= 1;
     }
@@ -2452,8 +2467,8 @@ f32 dCamera_c::radiusActorInSight(fopAc_ac_c* i_actor1, fopAc_ac_c* i_actor2, cX
         bVar2 |= 2;
     }
 
-    var_f29 = std::fabsf(cM_atan2f(pos2.x, -pos2.z));
-    var_f28 = std::fabsf(cM_atan2f(pos2.y, -pos2.z));
+    var_f29 = fabsf(cM_atan2f(pos2.x, -pos2.z));
+    var_f28 = fabsf(cM_atan2f(pos2.y, -pos2.z));
     if (var_f29 > sp30) {
         bVar2 |= 4;
     }
@@ -2478,25 +2493,25 @@ f32 dCamera_c::radiusActorInSight(fopAc_ac_c* i_actor1, fopAc_ac_c* i_actor2, cX
 
     f32 var_f31;
     if (bVar2 & 1) {
-        var_f31 = pos1.z + std::fabsf(pos1.x) / local_12c;
+        var_f31 = pos1.z + fabsf(pos1.x) / local_12c;
         if (var_f31 > ret) {
             ret = var_f31;
         }
     }
     if (bVar2 & 2) {
-        var_f31 = pos1.z + std::fabsf(pos1.y) / local_130;
+        var_f31 = pos1.z + fabsf(pos1.y) / local_130;
         if (var_f31 > ret) {
             ret = var_f31;
         }
     }
     if (bVar2 & 4) {
-        var_f31 = pos2.z + std::fabsf(pos2.x) / local_12c;
+        var_f31 = pos2.z + fabsf(pos2.x) / local_12c;
         if (var_f31 > ret) {
             ret = var_f31;
         }
     }
     if (bVar2 & 8) {
-        var_f31 = pos2.z + std::fabsf(pos2.y) / local_130;
+        var_f31 = pos2.z + fabsf(pos2.y) / local_130;
         if (var_f31 > ret) {
             ret = var_f31;
         }
@@ -2784,7 +2799,7 @@ bool dCamera_c::bumpCheck(u32 i_flags) {
             }
             wind_pow -= 0.3f;
             cSAngle angle = wind_globe.U() - mViewCache.mDirection.U();
-            mFovy += mCamSetup.WindShakeGap4Fvy() * cM_rndFX(wind_pow / 0.7f) * (1.0f - std::fabsf(angle.Norm()));
+            mFovy += mCamSetup.WindShakeGap4Fvy() * cM_rndFX(wind_pow / 0.7f) * (1.0f - fabsf(angle.Norm()));
 
 #if DEBUG
             dDbVw_Report(300, 180, "wind %f %f", wind_pow, angle.Norm());
@@ -2928,7 +2943,7 @@ bool dCamera_c::bumpCheck(u32 i_flags) {
                         cXyz cross;
                         f32 dot = VECDotProduct(normal1, normal2);
                         VECCrossProduct(normal1, normal2, &cross);
-                        if (chkCornerCos(dot) && std::fabsf(cross.y) > 0.5f
+                        if (chkCornerCos(dot) && fabsf(cross.y) > 0.5f
                                               && cBgW_CheckBWall(normal2->y)) {
                             var_r27 = 5;
                         } else {
@@ -3041,7 +3056,7 @@ bool dCamera_c::bumpCheck(u32 i_flags) {
                         field_0x96c += (1.0f - field_0x96c) * 0.1f;
                     }
                     if (sp0C || !(mMonitor.field_0xc < 5.0f)
-                              || !(std::fabsf(mPadInfo.mCStick.mLastPosX) < 0.05f)) {
+                              || !(fabsf(mPadInfo.mCStick.mLastPosX) < 0.05f)) {
                         field_0x968 = 0.2f;
                     } else {
                         field_0x968 *= mMonitor.field_0xc / 5.0f;
@@ -3984,7 +3999,7 @@ bool dCamera_c::chaseCamera(s32 param_0) {
             }
 
             cSAngle ang;
-            if ((chkFlag(0x100000) || sp1C || bVar6) && std::fabsf(mPadInfo.mCStick.mLastPosX) < 0.05f) {
+            if ((chkFlag(0x100000) || sp1C || bVar6) && fabsf(mPadInfo.mCStick.mLastPosX) < 0.05f) {
                 ang.Val(directionOf(mpPlayerActor).Inv());
             } else {
                 ang.Val(mViewCache.mDirection.U());
@@ -3999,13 +4014,13 @@ bool dCamera_c::chaseCamera(s32 param_0) {
             pos3 = pos;
             pos.y += dist;
             sp1AC = cXyz(mCenter - pos3).abs() * 8.0f;
-            sp1BC = std::fabsf(dist1 > sp1AC ? dist1 : sp1AC);
+            sp1BC = fabsf(dist1 > sp1AC ? dist1 : sp1AC);
 
             dist1 = val18 + (val17 - val18) * chase->field_0xa4;
-            sp1AC = std::fabsf(mFovy - dist1);
+            sp1AC = fabsf(mFovy - dist1);
             f32 sin = cSAngle(mFovy > dist1 ? mFovy : dist1).Sin();
             sp1AC = 100.0f * (sin * sin) * sp1AC;
-            sp1BC = std::fabsf(sp1BC > sp1AC ? sp1BC : sp1AC);
+            sp1BC = fabsf(sp1BC > sp1AC ? sp1BC : sp1AC);
             sp1BC *= 1.2f;
             sp1BC *= 0.00625f;
             chase->field_0x4 = (int)(JMAFastSqrt(sp1BC) * 2.2f) + 1;
@@ -4113,7 +4128,7 @@ bool dCamera_c::chaseCamera(s32 param_0) {
         mViewCache.mCenter += (pos - mViewCache.mCenter) * rate;
 
         f32 dist = dCamMath::xyzHorizontalDistance(pos, chase->field_0x58);
-        if (dist < std::fabsf(vec.x > vec.z ? vec.x : vec.z) + 20.0f) {
+        if (dist < fabsf(vec.x > vec.z ? vec.x : vec.z) + 20.0f) {
             cXyz attention_pos = attentionPos(mpPlayerActor);
             attention_pos.y -= 15.0f;
             dBgS_CamLinChk lin_chk;
@@ -4279,7 +4294,7 @@ bool dCamera_c::chaseCamera(s32 param_0) {
                 cSAngle ang = -mViewCache.mDirection.U();
                 delta = dCamMath::xyzRotateY(delta, ang);
                 cXyz vec5 = delta;
-                if (std::fabsf(vec5.y) < 200.0f) {
+                if (fabsf(vec5.y) < 200.0f) {
                     vec5.y = 0.0f;
                     vec5.x *= 0.5f;
                     f32 sp16C = vec5.abs();
@@ -4400,17 +4415,17 @@ bool dCamera_c::chaseCamera(s32 param_0) {
     bool sp11 = false;
     f32 sp140 = 0.05f;
     f32 last_pos_x = mPadInfo.mCStick.mLastPosX;
-    f32 sp138 = std::fabsf(last_pos_x);
+    f32 sp138 = fabsf(last_pos_x);
     f32 sp134 = mPadInfo.mCStick.mLastPosY;
-    f32 sp130 = std::fabsf(sp134);
+    f32 sp130 = fabsf(sp134);
     f32 sp12C = 8.0f;
     f32 sp128 = 12.0f;
     chase->field_0x93 = false;
 
-    if (sp11 || (!mCamParam.Flag(param_0, 0x40) && std::fabsf(last_pos_x) > sp140)) {
+    if (sp11 || (!mCamParam.Flag(param_0, 0x40) && fabsf(last_pos_x) > sp140)) {
         chase->field_0xac += (dCamMath::rationalBezierRatio(last_pos_x, 0.5f) * sp12C - chase->field_0xac) * chase->field_0x4c;
         ang3 = globe.U() + cSAngle(chase->field_0xac);
-        sp148 = std::fabsf(last_pos_x) - 0.05f;
+        sp148 = fabsf(last_pos_x) - 0.05f;
         if (mCamSetup.CheckFlag(0x1000) && mFakeAngleSys.field_0x0 == 0) {
             setUSOAngle();
         }
@@ -4846,6 +4861,15 @@ bool dCamera_c::lockonCamera(s32 param_0) {
         }
     }
 
+#if TARGET_PC
+    f32 sp194 = 1.0f;
+    if (mCurCamStyleTimer < lockon_change_timer && !lockon->field_0x2a) {
+        sp194 = dCamMath::rationalBezierRatio((f32)mCurCamStyleTimer / lockon_change_timer, 0.5f);
+        ang2 *= sp194;
+    } else if (mCurCamStyleTimer >= lockon_change_timer) {
+        lockon->field_0x2a = true;
+    }
+#else
     f32 sp194;
     if (mCurCamStyleTimer < lockon_change_timer && !lockon->field_0x2a) {
         sp194 = dCamMath::rationalBezierRatio((f32)mCurCamStyleTimer / lockon_change_timer, 0.5f);
@@ -4854,7 +4878,7 @@ bool dCamera_c::lockonCamera(s32 param_0) {
         lockon->field_0x2a = true;
         sp194 = 1.0f;
     }
-
+#endif
     cSAngle ang3(mViewCache.mDirection.U().Inv() - ang1);
 
     if (mCurCamStyleTimer != 0 && mCurCamStyleTimer < lockon_change_timer) {
@@ -4898,7 +4922,7 @@ bool dCamera_c::lockonCamera(s32 param_0) {
         sp0C = true;
     }
 
-    f32 fVar43 = 1.0f - std::fabsf(mPadInfo.mCStick.mLastPosY);
+    f32 fVar43 = 1.0f - fabsf(mPadInfo.mCStick.mLastPosY);
     f32 fVar44;
 
     if (bVar1) {
@@ -4957,12 +4981,12 @@ bool dCamera_c::lockonCamera(s32 param_0) {
     cSAngle u, v;
     cSAngle ang5 = globe.V() - lockon->field_0x34.V();
     if (sp0C) {
-        r = lockon->field_0x34.R() * 0.75f * std::fabsf(ang5.Cos());
+        r = lockon->field_0x34.R() * 0.75f * fabsf(ang5.Cos());
         u.Val(lockon->field_0x34.U() + (ang4 - lockon->field_0x34.U()) * lockon->field_0x58);
         v.Val(lockon->field_0x34.V() + ang5 * 0.05f);
     } else {
         r = lockon->field_0x34.R() + (sp184 - lockon->field_0x34.R()) *
-            lockon->field_0x54 * std::fabsf(ang5.Cos());
+            lockon->field_0x54 * fabsf(ang5.Cos());
         u.Val(lockon->field_0x34.U() + (ang4 - lockon->field_0x34.U()) * lockon->field_0x58);
         v.Val(lockon->field_0x34.V() + ang5 * lockon->field_0x58);
     }
@@ -4998,7 +5022,11 @@ bool dCamera_c::lockonCamera(s32 param_0) {
     f32 sp160;
     cSAngle ang6 = ang3 - ang2;
     curveWeight = mCamSetup.CurveWeight();
+    #if AVOID_UB
+    f32 sp15C = 0.0f;
+    #else
     f32 sp15C;
+    #endif
     f32 sp158 = mPadInfo.mCStick.mLastPosX;
     if (mCamParam.Flag(param_0, 0x40)) {
         sp158 = 0.0f;
@@ -5015,9 +5043,9 @@ bool dCamera_c::lockonCamera(s32 param_0) {
     }
 
     bool bVar3 = false;
-    if (std::fabsf(sp158) > 0.05f) {
+    if (fabsf(sp158) > 0.05f) {
         cSAngle ang = globe2.U() + cSAngle(dCamMath::rationalBezierRatio(sp158, 0.5f) * 7.5f);
-        sp15C = std::fabsf(sp158) - 0.05f;
+        sp15C = fabsf(sp158) - 0.05f;
         lockon->field_0x42 = ang;
         lockon->field_0x4c = 0.0f;
         bVar3 = true;
@@ -5081,7 +5109,7 @@ bool dCamera_c::lockonCamera(s32 param_0) {
         }
 
         ang6 = ang1.Inv() - mViewCache.mDirection.U();
-        if (std::fabsf(ang6.Degree()) < 2.0f && false) {
+        if (fabsf(ang6.Degree()) < 2.0f && false) {
             lockon->field_0x2a = true;
         }
         u2 += ang6 * sp15C * lockon->field_0x4c;
@@ -5109,7 +5137,7 @@ bool dCamera_c::lockonCamera(s32 param_0) {
     } else {
         lockon->field_0xc = 0;
         if (!mBG.field_0xc0.field_0x44 && !bVar1) {
-            v2 += (globe2.V() - v2) * fVar43 * std::fabsf(mViewCache.mDirection.V().Cos());
+            v2 += (globe2.V() - v2) * fVar43 * fabsf(mViewCache.mDirection.V().Cos());
         } else {
             cSAngle ang7 = lockon->field_0x34.V();
             ang7 *= cSAngle(lockon->field_0x34.U() - mViewCache.mDirection.U()).Cos();
@@ -5441,7 +5469,7 @@ bool dCamera_c::talktoCamera(s32 param_0) {
         if (talk->field_0x84 != 0) {
             talk->field_0x48 = 1;
         } else {
-            talk->field_0x48 = (int)(JMAFastSqrt(std::fabsf(mViewCache.mDirection.R() - talk->field_0x28.R())) / 2.0f);
+            talk->field_0x48 = (int)(JMAFastSqrt(fabsf(mViewCache.mDirection.R() - talk->field_0x28.R())) / 2.0f);
             if (talk->field_0x48 < 2) {
                 talk->field_0x48 = 2;
             }
@@ -5581,7 +5609,7 @@ bool dCamera_c::talktoCamera(s32 param_0) {
 
         for (i = 0; i < 36; i++) {
             sp26C = talk->field_0x28.U() - talk->field_0x30.U();
-            if (std::fabsf(sp26C.Degree()) < 10.0f) {
+            if (fabsf(sp26C.Degree()) < 10.0f) {
                 talk->field_0x28.U(talk->field_0x28.U() + sp270);
             } else {
                 if (!sp5B) {
@@ -7144,7 +7172,7 @@ bool dCamera_c::subjectCamera(s32 param_0) {
         f32 zoom_fovy = dCamMath::zoomFovy(val17 * 0.5f, tmp2) * 2.0f;
         mViewCache.mFovy += (zoom_fovy - mViewCache.mFovy) * val22;
         setComZoomScale(tmp2);
-        setComZoomForcus(1.0f - std::fabsf(sp88 - sp84) * -511.0f);
+        setComZoomForcus(1.0f - fabsf(sp88 - sp84) * -511.0f);
         if (check_owner_action(mPadID, 0x200000)) {
             setComStat(8);
         }
@@ -7235,12 +7263,12 @@ bool dCamera_c::magneCamera(s32 param_0) {
     cSAngle stack_238;
     if (mCurMode == 1) {
         stack_238 = sp54.Inv();
-    } else if (std::fabsf(cstick_x) > 0.05f) {
+    } else if (fabsf(cstick_x) > 0.05f) {
         stack_238 = magne->field_0x1c.U() + cSAngle(dCamMath::rationalBezierRatio(cstick_x, 0.5f) * 10.0f);
     } else {
         cSAngle stack_23c = sp54.Inv() - stack_230.U();
         f32 sin = stack_23c.Sin();
-        f32 tmp = std::fabsf(sin * mPadInfo.mMainStick.mLastValue);
+        f32 tmp = fabsf(sin * mPadInfo.mMainStick.mLastValue);
         f32 tmp2 = stack_23c.Cos() > 0.0f ? 8.0f : 4.0f;
         stack_238 = stack_230.U() + cSAngle(sin * tmp2 * dCamMath::rationalBezierRatio(tmp, 1.0f));
     }
@@ -7556,7 +7584,7 @@ bool dCamera_c::towerCamera(s32 param_0) {
             cXyz stack_21c = relationalPos(mpPlayerActor, &stack_210);
             f32 sp1A8 = cXyz(mEye - stack_21c).abs() - val7;
             f32 sp1A4 = cXyz(mCenter - stack_21c).abs() - val7;
-            f32 sp1A0 = std::fabsf(sp1A8 > sp1A4 ? sp1A8 : sp1A4);
+            f32 sp1A0 = fabsf(sp1A8 > sp1A4 ? sp1A8 : sp1A4);
             sp1A8 = heightOf(mpPlayerActor);
             sp1A0 /= (sp1A8 < 10.0f ? 10.0f : sp1A8);
             tower->field_0x4 = (int)(JMAFastSqrt(sp1A0) * sp220) + 1;
@@ -7678,9 +7706,9 @@ bool dCamera_c::towerCamera(s32 param_0) {
     cSAngle sp108;
     cSAngle sp104 = stack_454 + (stack_454 - stack_458) * sp188;
 
-    if (!mCamParam.Flag(param_0, 0x40) && std::fabsf(sp18C) > sp184) {
+    if (!mCamParam.Flag(param_0, 0x40) && fabsf(sp18C) > sp184) {
         cSAngle sp100 = mViewCache.mDirection.U() + cSAngle(dCamMath::rationalBezierRatio(sp18C, 0.5f) * sp180);
-        f32 sp17C = std::fabsf(sp18C) - sp184;
+        f32 sp17C = fabsf(sp18C) - sp184;
         sp108.Val(mViewCache.mDirection.U() + (sp100 - mViewCache.mDirection.U()) * sp17C);
         tower->field_0x6a = true;
         tower->field_0x78 += (0.8f - tower->field_0x78) * 0.05f;
@@ -10140,9 +10168,9 @@ bool dCamera_c::eventCamera(s32 param_0) {
             mEye = mCenter + mDirection.Xyz();
         }
 
-        int* sp90_i;
+        BE(int)* sp90_i;
         if (getEvStringData(sp90, "Trim", "DEFAULT") != false) {
-            sp90_i = (int*)sp90;
+            sp90_i = (BE(int)*)sp90;
             if (*sp90_i == 'STAN') {
                 mEventData.field_0x1c = 0;
             } else if (*sp90_i == 'VIST') {
@@ -10523,6 +10551,10 @@ int dCamera_c::StartShake(s32 i_length, u8* i_pattern, s32 i_flags, cXyz i_pos)
 #define PATTERN_LENGTH_MAX 4
 #endif
 
+    #if TARGET_PC
+    *(u32*)i_pattern = BSWAP32(*(u32*)i_pattern);
+    #endif
+
     if (i_length < 0 || i_length > PATTERN_LENGTH_MAX << 3) {
         OS_REPORT("camera: shake: too long data\n");
         i_length = PATTERN_LENGTH_MAX << 3;

src/d/d_cc_s.cpp

@@ -9,8 +9,9 @@
 #include "d/d_com_inf_game.h"
 #include "d/d_jnt_col.h"
 #include "f_op/f_op_actor_mng.h"
-
-#include "dusk/imgui/ImGuiConsole.hpp"
+#if TARGET_PC
+#include "dusk/settings.h"
+#endif
 
 class dCcS_HIO : public JORReflexible {
 public:
@@ -770,19 +771,19 @@ void dCcS::Draw() {
     #endif
 
 #if TARGET_PC
-#define IMGUI_TOGGLE_HIO_FLAG(status, flag) \
+#define DUSK_TOGGLE_HIO_FLAG(status, flag) \
         if (status) { \
             s_Hio.m_flags |= flag; \
         } else { \
             s_Hio.m_flags &= ~flag; \
         }
 
-    dusk::ImGuiMenuTools::CollisionViewSettings collisionViewSettings = dusk::g_imguiConsole.getCollisionViewSettings();
-    IMGUI_TOGGLE_HIO_FLAG(collisionViewSettings.m_enableAtView, dCcS_HIO::FLAG_AT_ON_e);
-    IMGUI_TOGGLE_HIO_FLAG(collisionViewSettings.m_enableTgView, dCcS_HIO::FLAG_TG_ON_e);
-    IMGUI_TOGGLE_HIO_FLAG(collisionViewSettings.m_enableCoView, dCcS_HIO::FLAG_CO_ON_e);
+    const auto& collisionViewSettings = dusk::getTransientSettings().collisionView;
+    DUSK_TOGGLE_HIO_FLAG(collisionViewSettings.enableAtView, dCcS_HIO::FLAG_AT_ON_e);
+    DUSK_TOGGLE_HIO_FLAG(collisionViewSettings.enableTgView, dCcS_HIO::FLAG_TG_ON_e);
+    DUSK_TOGGLE_HIO_FLAG(collisionViewSettings.enableCoView, dCcS_HIO::FLAG_CO_ON_e);
 
-    f32 view_opacity = 255 * (collisionViewSettings.m_colliderViewOpacity / 100.0f);
+    f32 view_opacity = 255 * (collisionViewSettings.colliderViewOpacity / 100.0f);
 #endif
 
     if (s_Hio.CheckAtOn()) {

src/d/d_cursor_mng.cpp

@@ -318,7 +318,7 @@ void dCsr_mng_c::bloObj_c::calcPaneObjNum(J2DPane* i_pane) {
     }
 
     JSUTreeIterator<J2DPane> iter = i_pane->getPaneTree()->getFirstChild();
-    while (iter != NULL) {
+    while (iter) {
         calcPaneObjNum(*iter);
         ++iter;
     }
@@ -334,7 +334,7 @@ void dCsr_mng_c::bloObj_c::createPaneObj(paneObj_c** i_panes, J2DPane* i_pane) {
     }
 
     JSUTreeIterator<J2DPane> iter = i_pane->getPaneTree()->getFirstChild();
-    while (iter != NULL) {
+    while (iter) {
         createPaneObj(i_panes, *iter);
         ++iter;
     }

src/d/d_drawlist.cpp

@@ -1398,11 +1398,20 @@ void dDlst_shadowSimple_c::set(cXyz* param_0, f32 param_1, f32 param_2, cXyz* pa
 }
 
 void dDlst_shadowControl_c::init() {
+#if TARGET_PC
+    // Increase shadow map resolution
+    static u16 l_realImageSize[2] = {1024, 512};
+#else
     static u16 l_realImageSize[2] = {192, 64};
+#endif
     for (int i = 0; i < 2; i++) {
         u16 size = l_realImageSize[i];
 
+#ifdef TARGET_PC
+        u32 buffer_size = 0x20; // No need to allocate memory for texture
+#else
         u32 buffer_size = GXGetTexBufferSize(size, size, 5, GX_DISABLE, 0);
+#endif
         field_0x15ef0[i] = JKR_NEW_ARRAY_ARGS(u8, buffer_size, 0x20);
         GXInitTexObj(&field_0x15eb0[i], field_0x15ef0[i], size, size, GX_TF_RGB5A3, GX_CLAMP,
                      GX_CLAMP, GX_DISABLE);
@@ -1467,11 +1476,18 @@ void dDlst_shadowControl_c::imageDraw(Mtx param_0) {
     int tex = 0;
     u16 r27;
     u16 r26;
+#ifdef TARGET_PC
+    bool needsRestore = false;
+#endif
     for (; shadowReal; shadowReal = shadowReal->getZsortNext()) {
         if (shadowReal->isUse()) {
             if (r29 == 0) {
                 r27 = GXGetTexObjWidth(field_0x15eb0 + tex);
                 r26 = r27 * 2;
+#ifdef TARGET_PC
+                GXCreateFrameBuffer(r26, r26);
+                needsRestore = true;
+#endif
                 GXSetViewport(0.0f, 0.0f, r26, r26, 0.0f, 1.0f);
                 GXSetScissor(0, 0, r26, r26);
             }
@@ -1499,6 +1515,11 @@ void dDlst_shadowControl_c::imageDraw(Mtx param_0) {
         GXPixModeSync();
         GXSetAlphaUpdate(GX_DISABLE);
     }
+#ifdef TARGET_PC
+    if (needsRestore) {
+        GXRestoreFrameBuffer();
+    }
+#endif
     GXSetClipMode(GX_CLIP_ENABLE);
     GXSetDither(GX_TRUE);
 }
@@ -1516,7 +1537,7 @@ void dDlst_shadowControl_c::draw(Mtx param_0) {
     dKy_GxFog_set();
 
     GXSetChanCtrl(GX_ALPHA0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
-    GXSETARRAY(GX_VA_POS, l_shadowVolPos, sizeof(l_shadowVolPos), sizeof(l_shadowVolPos[0]));
+    GXSETARRAY(GX_VA_POS, l_shadowVolPos, sizeof(l_shadowVolPos), sizeof(l_shadowVolPos[0]), true);
     GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, GX_TEXMTX0);
     GXSetNumTevStages(1);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
@@ -1548,7 +1569,7 @@ void dDlst_shadowControl_c::draw(Mtx param_0) {
 
     GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGB8, 0);
-    GXSETARRAY(GX_VA_POS, l_simpleShadowPos, sizeof(l_simpleShadowPos), sizeof(l_simpleShadowPos[0]));
+    GXSETARRAY(GX_VA_POS, l_simpleShadowPos, sizeof(l_simpleShadowPos), sizeof(l_simpleShadowPos[0]), true);
     GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
     GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
     GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
@@ -1636,7 +1657,7 @@ int dDlst_shadowControl_c::setReal(u32 param_1, s8 param_2, J3DModel* param_3, c
     u32 rv = pdVar12->set(mNextID, param_3, param_4, param_5, param_6, param_7, dVar17, dVar16);
     if (!rv) {
         return 0;
-    } 
+    }
     mRealNum++;
     if (pdVar10 == NULL) {
         if (pdVar11 == NULL) {
@@ -1860,6 +1881,12 @@ int dDlst_list_c::set(dDlst_base_c**& p_start, dDlst_base_c**& p_end, dDlst_base
 void dDlst_list_c::draw(dDlst_base_c** p_start, dDlst_base_c** p_end) {
     for (; p_start < p_end; p_start++) {
         dDlst_base_c* dlst = *p_start;
+
+#if DEBUG && TARGET_PC
+        char buf[64];
+        snprintf(buf, sizeof(buf), "%s::draw()", typeid(dlst).name());
+        GXScopedDebugGroup scope(buf);
+#endif
         dlst->draw();
     }
 }

src/d/d_error_msg.cpp

@@ -15,6 +15,7 @@
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_graphic.h"
 
+#if !TARGET_PC
 #include "assets/black_tex.h"
 #include "assets/msg_data.h"
 #if VERSION == VERSION_GCN_PAL
@@ -24,6 +25,7 @@
 #include "assets/msg_data_it.h"
 #endif
 #include "assets/font_data.h"
+#endif
 
 #define MSG_READING_DISC 0
 #define MSG_COVER_OPEN   1
@@ -49,6 +51,7 @@ struct BMG_INF1 : JUTDataBlockHeader {
 #endif
 
 static void messageSet(u32 status, bool i_drawBg) {
+    #if !TARGET_PC
     BMG_INF1* inf1;
     const char* msg_p;
 
@@ -177,9 +180,11 @@ static void messageSet(u32 status, bool i_drawBg) {
     tpane.draw(x, y + 10.0f, FB_WIDTH, HBIND_LEFT);
     #endif
     #endif
+    #endif
 }
 
 void dDvdErrorMsg_c::draw(s32 status) {
+    #if !TARGET_PC
     JUtility::TColor backColor = g_clearColor;
     JFWDisplay::getManager()->setClearColor(backColor);
     mDoGph_gInf_c::beginRender();
@@ -207,6 +212,7 @@ void dDvdErrorMsg_c::draw(s32 status) {
 
     mDoGph_gInf_c::endRender();
     JFWDisplay::getManager()->resetFader();
+    #endif
 }
 
 bool dDvdErrorMsg_c::execute() {
@@ -237,6 +243,7 @@ bool dDvdErrorMsg_c::execute() {
 static u8 l_captureAlpha = 0xFF;
 
 static void drawCapture(u8 alpha) {
+    #if !TARGET_PC
     static bool l_texCopied = false;
 
     if (!l_texCopied) {
@@ -251,9 +258,6 @@ static void drawCapture(u8 alpha) {
     GXSetAlphaUpdate(GX_FALSE);
     j3dSys.drawInit();
 
-#ifdef TARGET_PC
-    mDoGph_gInf_c::getFrameBufferTexObj()->reset();
-#endif
     GXInitTexObj(mDoGph_gInf_c::getFrameBufferTexObj(), mDoGph_gInf_c::getFrameBufferTex(), FB_WIDTH / 2, FB_HEIGHT / 2, (GXTexFmt)mDoGph_gInf_c::getFrameBufferTimg()->format, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(mDoGph_gInf_c::getFrameBufferTexObj(), GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
     GXLoadTexObj(mDoGph_gInf_c::getFrameBufferTexObj(), GX_TEXMAP0);
@@ -293,6 +297,7 @@ static void drawCapture(u8 alpha) {
     mDoGph_drawFilterQuad(1, 1);
     mDoGph_gInf_c::endRender();
     JFWDisplay::getManager()->resetFader();
+    #endif
 }
 
 bool dShutdownErrorMsg_c::execute() {
@@ -320,6 +325,5 @@ bool dShutdownErrorMsg_c::execute() {
             mDoRst_reset(1, 1, 1);
         }
     }
-
     return true;
 }

src/d/d_file_select.cpp

@@ -70,7 +70,11 @@ dFs_HIO_c::dFs_HIO_c() {
     select_icon_appear_frames = 5;
     appear_display_wait_frames = 15;
     field_0x000d = 15;
+    #if TARGET_PC
+    card_wait_frames = 0;
+    #else
     card_wait_frames = 90;
+    #endif
     test_frame_counts[0] = 1.11f;
     test_frame_counts[1] = 1.11f;
     test_frame_counts[2] = 1.11f;
@@ -1189,7 +1193,13 @@ void dFile_select_c::menuSelect() {
 
 // Handles copy / start / delete actions depending on which menu is selected from menuSelect
 void dFile_select_c::menuSelectStart() {
-    mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0);
+    #if TARGET_PC
+    if (!dusk::getSettings().game.hideTvSettingsScreen || mSelectMenuNum != 1) {
+        mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0);
+    }
+    #else
+        mDoAud_seStart(Z2SE_SY_CURSOR_OK, NULL, 0, 0);
+    #endif
 
     if (mSelectMenuNum == 1) {
         dComIfGs_setCardToMemory((u8*)mSaveData, mSelectNum);
@@ -2091,7 +2101,12 @@ void dFile_select_c::yesnoCursorShow() {
         Vec pos = mYnSelPane[field_0x0268]->getGlobalVtxCenter(0, 0);
         mSelIcon->setPos(pos.x, pos.y, mYnSelPane[field_0x0268]->getPanePtr(), true);
         mSelIcon->setAlphaRate(1.0f);
+
+        #if TARGET_PC
+        mSelIcon->setParam(0.96f * mDoGph_gInf_c::hudAspectScaleUp, 0.84f, 0.06f, 0.5f, 0.5f);
+        #else
         mSelIcon->setParam(0.96f, 0.84f, 0.06f, 0.5f, 0.5f);
+        #endif
     }
 }
 
@@ -2243,7 +2258,12 @@ void dFile_select_c::YesNoCancelMove() {
                 mSelIcon->setPos(vtxCenter.x, vtxCenter.y,
                                  m3mSelPane[mSelectMenuNum]->getPanePtr(), true);
                 mSelIcon->setAlphaRate(1.0f);
+
+                #if TARGET_PC
+                mSelIcon->setParam(0.96f * mDoGph_gInf_c::hudAspectScaleUp, 0.84f, 0.06f, 0.5f, 0.5f);
+                #else
                 mSelIcon->setParam(0.96f, 0.84f, 0.06f, 0.5f, 0.5f);
+                #endif
 
                 #if PLATFORM_WII || PLATFORM_SHIELD
                 field_0x4333 = mSelectMenuNum;
@@ -3126,7 +3146,13 @@ void dFile_select_c::screenSet() {
 
     mSelIcon = JKR_NEW dSelect_cursor_c(0, 1.0f, NULL);
     JUT_ASSERT(5209, mSelIcon != NULL);
+
+    #if TARGET_PC
+    mSelIcon->setParam(0.96f * mDoGph_gInf_c::hudAspectScaleUp, 0.94f, 0.03f, 0.7f, 0.7f);
+    #else
     mSelIcon->setParam(0.96f, 0.94f, 0.03f, 0.7f, 0.7f);
+    #endif
+
     Vec vtxCenter;
     vtxCenter = mSelFilePanes[mSelectNum]->getGlobalVtxCenter(false, 0);
     mSelIcon->setPos(vtxCenter.x, vtxCenter.y, mSelFilePanes[mSelectNum]->getPanePtr(), true);
@@ -3257,7 +3283,13 @@ void dFile_select_c::screenSetCopySel() {
 
     mSelIcon2 = JKR_NEW dSelect_cursor_c(0, 1.0f, NULL);
     JUT_ASSERT(5406, mSelIcon2 != NULL);
+
+    #if TARGET_PC
+    mSelIcon2->setParam(0.96f * mDoGph_gInf_c::hudAspectScaleUp, 0.94f, 0.03f, 0.7f, 0.7f);
+    #else
     mSelIcon2->setParam(0.96f, 0.94f, 0.03f, 0.7f, 0.7f);
+    #endif
+
     Vec center = mCpSelPane[0]->getGlobalVtxCenter(false, 0);
     mSelIcon2->setPos(center.x, center.y, mCpSelPane[0]->getPanePtr(), true);
     mSelIcon2->setAlphaRate(0.0f);
@@ -3647,7 +3679,12 @@ void dFile_select_c::selFileCursorShow() {
     Vec local_1c = mSelFilePanes[mSelectNum]->getGlobalVtxCenter(false, 0);
     mSelIcon->setPos(local_1c.x, local_1c.y, mSelFilePanes[mSelectNum]->getPanePtr(), true);
     mSelIcon->setAlphaRate(1.0f);
+
+    #if TARGET_PC
+    mSelIcon->setParam(0.96f * mDoGph_gInf_c::hudAspectScaleUp, 0.94f, 0.03f, 0.7f, 0.7f);
+    #else
     mSelIcon->setParam(0.96f, 0.94f, 0.03f, 0.7f, 0.7f);
+    #endif
 }
 
 void dFile_select_c::menuWakuAlpahAnmInit(u8 i_idx, u8 param_1, u8 param_2, u8 param_3) {
@@ -3689,7 +3726,12 @@ void dFile_select_c::menuCursorShow() {
         Vec local_24 = m3mSelPane[mSelectMenuNum]->getGlobalVtxCenter(false, 0);
         mSelIcon->setPos(local_24.x, local_24.y, m3mSelPane[mSelectMenuNum]->getPanePtr(), true);
         mSelIcon->setAlphaRate(1.0f);
+
+        #if TARGET_PC
+        mSelIcon->setParam(0.96f * mDoGph_gInf_c::hudAspectScaleUp, 0.84f, 0.06f, 0.5f, 0.5f);
+        #else
         mSelIcon->setParam(0.96f, 0.84f, 0.06f, 0.5f, 0.5f);
+        #endif
     }
 }
 
@@ -3731,7 +3773,74 @@ bool dFile_select_c::yesnoWakuAlpahAnm(u8 param_1) {
     return rv;
 }
 
+#if TARGET_PC
+void dFile_select_c::fileSelectWide() {
+    mYnSel.ScrYn->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    mYnSel.ScrYn->translate(mDoGph_gInf_c::getMinXF(), 0.0f);
+
+    mYnSel.ScrYn->search(MULTI_CHAR('w_no_t'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mYnSel.ScrYn->search(MULTI_CHAR('f_no_t'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mYnSel.ScrYn->search(MULTI_CHAR('w_yes_t'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mYnSel.ScrYn->search(MULTI_CHAR('f_yes_t'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    m3mSel.Scr3m->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    m3mSel.Scr3m->translate(mDoGph_gInf_c::getMinXF(), 0.0f);
+
+    m3mSel.Scr3m->search(MULTI_CHAR('w_sta'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    m3mSel.Scr3m->search(MULTI_CHAR('f_sta'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    m3mSel.Scr3m->search(MULTI_CHAR('w_del'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    m3mSel.Scr3m->search(MULTI_CHAR('f_del'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    m3mSel.Scr3m->search(MULTI_CHAR('w_cop_t'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    m3mSel.Scr3m->search(MULTI_CHAR('f_cop_t'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    fileSel.Scr->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
+    fileSel.Scr->translate(mDoGph_gInf_c::getMinXF(), 0.0f);
+
+    fileSel.Scr->search(MULTI_CHAR('t_for'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('t_for1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    fileSel.Scr->search(MULTI_CHAR('w_btn_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    fileSel.Scr->search(MULTI_CHAR('w_n_bk00'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_n_bk01'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_n_bk02'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    fileSel.Scr->search(MULTI_CHAR('w_dat_i0'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_dat_i1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_dat_i2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    mCpSel.Scr->search(MULTI_CHAR('w_dat_i1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mCpSel.Scr->search(MULTI_CHAR('w_dat_i2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mCpSel.Scr->search(MULTI_CHAR('w_n_bk01'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mCpSel.Scr->search(MULTI_CHAR('w_n_bk02'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    mSelDt.ScrDt->search(MULTI_CHAR('tate_n0'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mSelDt.ScrDt->search(MULTI_CHAR('tate_n1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mSelDt.ScrDt->search(MULTI_CHAR('ken_n0'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mSelDt.ScrDt->search(MULTI_CHAR('ken_n1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mSelDt.ScrDt->search(MULTI_CHAR('fuku_n0'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mSelDt.ScrDt->search(MULTI_CHAR('fuku_n1'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    mSelDt.ScrDt->search(MULTI_CHAR('fuku_n2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+
+    // Spirals
+    fileSel.Scr->search(MULTI_CHAR('w_uzu00'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu01'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu02'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu03'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu04'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu05'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu06'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu07'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu08'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    fileSel.Scr->search(MULTI_CHAR('w_uzu09'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+}
+#endif
+
 void dFile_select_c::_draw() {
+    #if TARGET_PC
+    fileSelectWide();
+    #endif
+
     if (!mHasDrawn) {
         dComIfGd_set2DOpa(&fileSel);