Various imps

Former-commit-id: 7043befead

src/Dolphin/ai.c

@@ -0,0 +1,316 @@
+#include "dolphin/ai.h"
+#include "dolphin/dsp_regs.h"
+#include "dolphin/os.h"
+
+const char* __AIVersion = "<< Dolphin SDK - AI\trelease build: Sep  5 2002 05:34:25 (0x2301) >>";
+
+static AISCallback __AIS_Callback = NULL;
+static AIDCallback __AID_Callback = NULL;
+static u8* __CallbackStack;
+static u8* __OldStack;
+static volatile s32 __AI_init_flag = FALSE;
+static volatile s32 __AID_Active = FALSE;
+
+static OSTime bound_32KHz;
+static OSTime bound_48KHz;
+static OSTime min_wait;
+static OSTime max_wait;
+static OSTime buffer;
+
+void __AISHandler(s16 interrupt, OSContext* context);
+void __AIDHandler(s16 interrupt, OSContext* context);
+void __AICallbackStackSwitch(register AIDCallback cb);
+void __AI_SRC_INIT(void);
+
+AIDCallback AIRegisterDMACallback(AIDCallback callback) {
+  AIDCallback ret;
+  s32 oldInts;
+
+  ret = __AID_Callback;
+  oldInts = OSDisableInterrupts();
+  __AID_Callback = callback;
+  OSRestoreInterrupts(oldInts);
+  return ret;
+}
+
+void AIInitDMA(u32 addr, u32 length) {
+  s32 oldInts;
+  oldInts = OSDisableInterrupts();
+  __DSPRegs[24] = (u16)((__DSPRegs[24] & ~0x3FF) | (addr >> 16));
+  __DSPRegs[25] = (u16)((__DSPRegs[25] & ~0xFFE0) | (0xffff & addr));
+  __DSPRegs[27] = (u16)((__DSPRegs[27] & ~0x7FFF) | (u16)((length >> 5) & 0xFFFF));
+  OSRestoreInterrupts(oldInts);
+}
+
+void AIStartDMA() { __DSPRegs[27] |= 0x8000; }
+
+void AIStopDMA(void) { __DSPRegs[27] &= ~0x8000; }
+
+u32 AIGetDMAStartAddr(void) { return (u32)((__DSPRegs[24] & 0x03ff) << 16) | (__DSPRegs[25] & 0xffe0); }
+
+AISCallback AIRegisterStreamCallback(AISCallback callback) {
+  AISCallback ret;
+  s32 oldInts;
+
+  ret = __AIS_Callback;
+  oldInts = OSDisableInterrupts();
+  __AIS_Callback = callback;
+  OSRestoreInterrupts(oldInts);
+  return ret;
+}
+
+void AIResetStreamSampleCount(void) { __AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20; }
+
+void AISetStreamTrigger(u32 trigger) { __AIRegs[3] = trigger; }
+
+void AISetStreamPlayState(u32 state) {
+  s32 oldInts;
+  u8 volRight;
+  u8 volLeft;
+
+  if (state == AIGetStreamPlayState()) {
+    return;
+  }
+  if ((AIGetStreamSampleRate() == 0U) && (state == 1)) {
+    volRight = AIGetStreamVolRight();
+    volLeft = AIGetStreamVolLeft();
+    AISetStreamVolRight(0);
+    AISetStreamVolLeft(0);
+    oldInts = OSDisableInterrupts();
+    __AI_SRC_INIT();
+    __AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
+    __AIRegs[0] = (__AIRegs[0] & ~1) | 1;
+    OSRestoreInterrupts(oldInts);
+    AISetStreamVolLeft(volRight);
+    AISetStreamVolRight(volLeft);
+  } else {
+    __AIRegs[0] = (__AIRegs[0] & ~1) | state;
+  }
+}
+
+u32 AIGetStreamPlayState() { return __AIRegs[0] & 1; }
+
+void AISetDSPSampleRate(u32 rate) {
+  u32 state;
+  s32 oldInts;
+  u8 left;
+  u8 right;
+  u32 sampleRate;
+
+  if (rate == AIGetDSPSampleRate()) {
+    return;
+  }
+
+  __AIRegs[0] &= ~0x40;
+  if (rate == 0) {
+    left = AIGetStreamVolLeft();
+    right = AIGetStreamVolRight();
+    state = AIGetStreamPlayState();
+    sampleRate = AIGetStreamSampleRate();
+    AISetStreamVolLeft(0);
+    AISetStreamVolRight(0);
+    oldInts = OSDisableInterrupts();
+    __AI_SRC_INIT();
+    __AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
+    __AIRegs[0] = (__AIRegs[0] & ~2) | (sampleRate * 2);
+    __AIRegs[0] = (__AIRegs[0] & ~1) | state;
+    __AIRegs[0] |= 0x40;
+    OSRestoreInterrupts(oldInts);
+    AISetStreamVolLeft(left);
+    AISetStreamVolRight(right);
+  }
+}
+
+u32 AIGetDSPSampleRate() { return ((__AIRegs[0] >> 6) & 1) ^ 1; }
+
+void __AI_set_stream_sample_rate(u32 rate) {
+  s32 oldInts;
+  s32 state;
+  u8 left;
+  u8 right;
+  s32 temp_r26;
+
+  if (rate == AIGetStreamSampleRate()) {
+    return;
+  }
+  state = AIGetStreamPlayState();
+  left = AIGetStreamVolLeft();
+  right = AIGetStreamVolRight();
+  AISetStreamVolRight(0);
+  AISetStreamVolLeft(0);
+  temp_r26 = __AIRegs[0] & 0x40;
+  __AIRegs[0] &= ~0x40;
+  oldInts = OSDisableInterrupts();
+  __AI_SRC_INIT();
+  __AIRegs[0] |= temp_r26;
+  __AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
+  __AIRegs[0] = (__AIRegs[0] & ~2) | (rate * 2);
+  OSRestoreInterrupts(oldInts);
+  AISetStreamPlayState(state);
+  AISetStreamVolLeft(left);
+  AISetStreamVolRight(right);
+}
+
+u32 AIGetStreamSampleRate() { return (__AIRegs[0] >> 1) & 1; }
+
+void AISetStreamVolLeft(u8 volume) { __AIRegs[1] = (__AIRegs[1] & ~0xFF) | (volume & 0xFF); }
+
+u8 AIGetStreamVolLeft() { return __AIRegs[1]; }
+
+void AISetStreamVolRight(u8 volume) { __AIRegs[1] = (__AIRegs[1] & ~0xFF00) | ((volume & 0xFF) << 8); }
+
+u8 AIGetStreamVolRight() { return __AIRegs[1] >> 8; }
+
+void AIInit(u8* stack) {
+  if (__AI_init_flag == TRUE) {
+    return;
+  }
+
+  OSRegisterVersion(__AIVersion);
+  bound_32KHz = OSNanosecondsToTicks(31524);
+  bound_48KHz = OSNanosecondsToTicks(42024);
+  min_wait = OSNanosecondsToTicks(42000);
+  max_wait = OSNanosecondsToTicks(63000);
+  buffer = OSNanosecondsToTicks(3000);
+
+  AISetStreamVolRight(0);
+  AISetStreamVolLeft(0);
+  AISetStreamTrigger(0);
+  AIResetStreamSampleCount();
+  __AI_set_stream_sample_rate(1);
+  AISetDSPSampleRate(0);
+  __AIS_Callback = 0;
+  __AID_Callback = 0;
+  __CallbackStack = stack;
+  __OSSetInterruptHandler(5, __AIDHandler);
+  __OSUnmaskInterrupts(0x04000000);
+  __OSSetInterruptHandler(8, __AISHandler);
+  __OSUnmaskInterrupts(0x800000);
+  __AI_init_flag = TRUE;
+}
+
+void __AISHandler(s16 interrupt, OSContext* context) {
+  OSContext tmpContext;
+  __AIRegs[0] |= 8;
+  OSClearContext(&tmpContext);
+  OSSetCurrentContext(&tmpContext);
+  if (__AIS_Callback != NULL) {
+    __AIS_Callback(__AIRegs[2]);
+  }
+  OSClearContext(&tmpContext);
+  OSSetCurrentContext(context);
+}
+
+void __AIDHandler(s16 interrupt, OSContext* context) {
+  OSContext tempContext;
+  u32 temp = __DSPRegs[5];
+  __DSPRegs[5] = (temp & ~0xA0) | 8;
+  OSClearContext(&tempContext);
+  OSSetCurrentContext(&tempContext);
+  if (__AID_Callback && !__AID_Active) {
+    __AID_Active = TRUE;
+    if (__CallbackStack) {
+      __AICallbackStackSwitch(__AID_Callback);
+    } else {
+      __AID_Callback();
+    }
+
+    __AID_Active = FALSE;
+  }
+
+  OSClearContext(&tempContext);
+  OSSetCurrentContext(context);
+}
+
+// clang-format off
+asm void __AICallbackStackSwitch(register AIDCallback cb) {
+  // Allocate stack frame
+  fralloc
+
+  // Store current stack
+  lis r5, __OldStack@ha
+  addi r5, r5, __OldStack@l
+  stw r1, 0(r5)
+
+  // Load stack for callback
+  lis r5, __CallbackStack@ha 
+  addi r5, r5, __CallbackStack@l 
+  lwz r1,0(r5)
+
+  // Move stack down 8 bytes
+  subi r1, r1, 8
+  // Call callback
+  mtlr cb 
+  blrl
+
+  // Restore old stack
+  lis r5, __OldStack @ha 
+  addi r5, r5, __OldStack@l 
+  lwz r1,0(r5)
+
+  // Free stack frame
+  frfree
+
+  blr
+}
+// clang-format on
+
+void __AI_SRC_INIT(void) {
+  OSTime rise32 = 0;
+  OSTime rise48 = 0;
+  OSTime diff = 0;
+  OSTime unused1 = 0;
+  OSTime temp = 0;
+  u32 temp0 = 0;
+  u32 temp1 = 0;
+  u32 done = 0;
+  u32 walking = 0;
+  u32 unused2 = 0;
+  u32 initCnt = 0;
+
+  walking = 0;
+  initCnt = 0;
+  temp = 0;
+
+  while (!done) {
+    __AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
+    __AIRegs[0] &= ~2;
+    __AIRegs[0] = (__AIRegs[0] & ~1) | 1;
+
+    temp0 = __AIRegs[2];
+
+    while (temp0 == __AIRegs[2])
+      ;
+    rise32 = OSGetTime();
+
+    __AIRegs[0] = (__AIRegs[0] & ~2) | 2;
+    __AIRegs[0] = (__AIRegs[0] & ~1) | 1;
+
+    temp1 = __AIRegs[2];
+    while (temp1 == __AIRegs[2])
+      ;
+
+    rise48 = OSGetTime();
+
+    diff = rise48 - rise32;
+    __AIRegs[0] &= ~2;
+    __AIRegs[0] &= ~1;
+
+    if (diff < (bound_32KHz - buffer)) {
+      temp = min_wait;
+      done = 1;
+      ++initCnt;
+    } else if (diff >= (bound_32KHz + buffer) && diff < (bound_48KHz - buffer)) {
+      temp = max_wait;
+      done = 1;
+      ++initCnt;
+    } else {
+      done = 0;
+      walking = 1;
+      ++initCnt;
+    }
+  }
+
+  while ((rise48 + temp) > OSGetTime())
+    ;
+}

src/Dolphin/card/CARDBios.c

@@ -0,0 +1,103 @@
+CARDControl __CARDBlock[2];
+DVDDiskID __CARDDiskNone;
+
+void __CARDDefaultApiCallback(s32 chan, s32 result) {
+}
+
+void __CARDExtHandler(s32 chan, OSContext* context) {
+    CARDControl* card;
+    CARDCallback callback;
+
+    card = &__CARDBlock[chan];
+    if (card->attached) {
+        card->attached = FALSE;
+        EXISetExiCallback(chan, 0);
+        OSCancelAlarm(&card->alarm);
+        callback = card->exiCallback;
+    
+        if (callback) {
+            card->exiCallback = 0;
+            callback(chan, CARD_RESULT_NOCARD);
+        }
+    
+        if (card->result != CARD_RESULT_BUSY) {
+            card->result = CARD_RESULT_NOCARD;
+        }
+    
+        callback = card->extCallback;
+        if (callback && CARD_MAX_MOUNT_STEP <= card->mountStep) {
+            card->extCallback = 0;
+            callback(chan, CARD_RESULT_NOCARD);
+        }
+    }
+}
+
+void __CARDExiHandler(s32 chan, OSContext* context) {
+    CARDControl* card;
+    CARDCallback callback;
+    u8 status;
+    s32 result;
+
+    card = &__CARDBlock[chan];
+
+    OSCancelAlarm(&card->alarm);
+
+    if (!card->attached) {
+        return;
+    }
+
+    if (!EXILock(chan, 0, 0)) {
+        result = CARD_RESULT_FATAL_ERROR;
+        goto fatal;
+    }
+
+    if ((result = __CARDReadStatus(chan, &status)) < 0 || (result = __CARDClearStatus(chan)) < 0) {
+        goto error;
+    }
+
+    if ((result = (status & 0x18) ? CARD_RESULT_IOERROR : CARD_RESULT_READY) == CARD_RESULT_IOERROR && --card->retry > 0) {
+        result = Retry(chan);
+        if (result >= 0) {
+            return;
+        }
+        goto fatal;
+    }
+
+error:
+    EXIUnlock(chan);
+
+fatal:
+    callback = card->exiCallback;
+    if (callback) {
+        card->exiCallback = 0;
+        callback(chan, result);
+    }
+}
+
+void __CARDTxHandler(s32 chan, OSContext* context) {
+    CARDControl* card;
+    CARDCallback callback;
+    BOOL err;
+
+    card = &__CARDBlock[chan];
+    err = !EXIDeselect(chan);
+    EXIUnlock(chan);
+    callback = card->txCallback;
+    if (callback) {
+        card->txCallback = 0;
+        callback(chan, (!err && EXIProbe(chan)) ? CARD_RESULT_READY : CARD_RESULT_NOCARD);
+    }
+}
+
+void __CARDUnlockedHandler(s32 chan, OSContext* context) {
+    CARDControl* card;
+    CARDCallback callback;
+
+    card = &__CARDBlock[chan];
+    callback = card->unlockCallback;
+    if (callback) {
+        card->unlockCallback = 0;
+        callback(chan, EXIProbe(chan) ? CARD_RESULT_UNLOCKED : CARD_RESULT_NOCARD);
+    }
+}
+

src/MetroidPrime/CObjectList.cpp

@@ -0,0 +1,46 @@
+#include "MetroidPrime/CObjectList.hpp"
+
+CObjectList::SObjectListEntry::SObjectListEntry() : mEnt(nullptr), mNext(-1), mPrev(-1) {}
+
+CObjectList::CObjectList(EGameObjectList list)
+: mListType(list)
+, mFirstId(-1)
+, mCount(0) {
+    for (s32 i = 0; i < kMaxObjects; ++i) {
+        mObjects[i] = SObjectListEntry();
+    }
+}
+
+bool CObjectList::IsQualified(CEntity& ent) { return true; }
+
+void CObjectList::AddObject(CEntity& ent) {
+    if (IsQualified(ent)) {
+        s16 next = -1;
+        if (mFirstId != -1) {
+            mObjects[this->mFirstId].mPrev = ent.GetUniqueId().Value();
+            next = mFirstId;
+        }
+        mFirstId = ent.GetUniqueId().Value();
+        SObjectListEntry* entry = &mObjects[ent.GetUniqueId().Value()];
+        entry->mEnt = &ent;
+        entry->mNext = next;
+        entry->mPrev = -1;
+        ++mCount;
+    }
+}
+
+void CObjectList::RemoveObject(TUniqueId uid) {}
+
+CEntity* CObjectList::GetObjectById() {}
+
+const CEntity* CObjectList::GetObjectById() const {}
+
+CEntity* CObjectList::GetValidObjectById(TUniqueId uid) {}
+
+const CEntity* CObjectList::GetValidObjectById(TUniqueId uid) const {}
+
+CEntity* CObjectList::operator[](s32 idx) {}
+
+const CEntity* CObjectList::operator[](s32 idx) const {}
+
+const CEntity* CObjectList::GetValidObjectByIndex(s32 idx) const {}

src/MetroidPrime/Cameras/CCameraHint.cpp

@@ -0,0 +1,27 @@
+#include "MetroidPrime/Cameras/CCameraHint.hpp"
+#include "Kyoto/Alloc/CMemory.hpp"
+
+CCameraHint::CCameraHint(u32 overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, float minDist, float maxDist, float backwardsDist,
+                         CVector3f* lookAtOffset, CVector3f* chaseLookAtOffset, CVector3f* ballToCam, float fov, float attitudeRange,
+                         float azimuthRange, float anglePerSecond, float clampVelRange, float clampRotRange, float elevation,
+                         float InterpolationTime, float clampVelTime, float controlInterpDur)
+: mOverrideFlags(overrideFlags)
+, mBehaviour(behaviour)
+, mMinDist(minDist)
+, mMaxDist(maxDist)
+, mBackwardsDist(backwardsDist)
+, mLookAtOffset(lookAtOffset)
+, mChaseLookAtOffset(chaseLookAtOffset)
+, mBallToCam(ballToCam)
+, mFov(fov)
+, mAttitudeRange(attitudeRange)
+, mAzimuthRnage(azimuthRange)
+, mAnglePerSecond(anglePerSecond)
+, mClampVelRange(clampVelRange)
+, mClampRotRange(clampRotRange)
+, mElevation(elevation)
+, mInterpolateTime(interpolateTime)
+, mClampVelTime(clampVelTime)
+, mControlInterpDur(controlInterpDur) {}
+
+CCameraHint::~CCameraHint() {}

src/musyx/synth_ac.c

@@ -1,22 +1,54 @@
 #include "musyx/musyx_priv.h"
 
-s32 sndPitchUpOne(u16 note) {
-    return note * 1.059463f;
-}
+extern SynthInfo synthInfo;
+
+static float toneup_tab[128] = {
+    1.000000,    1.059464,    1.122462,    1.189207,    1.259921,    1.334840,    1.414214,    1.498307,    1.587401,   1.681793,
+    1.781798,    1.887749,    2.000001,    2.118927,    2.244925,    2.378415,    2.519843,    2.669681,    2.828428,   2.996615,
+    3.174804,    3.363587,    3.563597,    3.775498,    4.000002,    4.237854,    4.489850,    4.756830,    5.039686,   5.339362,
+    5.656857,    5.993231,    6.349607,    6.727175,    7.127193,    7.550998,    8.000004,    8.475709,    8.979701,   9.513661,
+    10.079373,   10.678724,   11.313714,   11.986463,   12.699215,   13.454350,   14.254387,   15.101996,   16.000008,  16.951418,
+    17.959402,   19.027323,   20.158747,   21.357449,   22.627428,   23.972925,   25.398430,   26.908699,   28.508774,  30.203993,
+    32.000015,   33.902836,   35.918804,   38.054646,   40.317493,   42.714897,   45.254856,   47.945850,   50.796860,  53.817398,
+    57.017548,   60.407986,   64.000031,   67.805672,   71.837608,   76.109291,   80.634987,   85.429794,   90.509712,  95.891701,
+    101.593719,  107.634796,  114.035095,  120.815971,  128.000061,  135.611343,  143.675217,  152.218582,  161.269974, 170.859589,
+    181.019424,  191.783401,  203.187439,  215.269592,  228.070190,  241.631943,  256.000122,  271.222687,  287.350433, 304.437164,
+    322.539948,  341.719177,  362.038849,  383.566803,  406.374878,  430.539185,  456.140381,  483.263885,  512.000244, 542.445374,
+    574.700867,  608.874329,  645.079895,  683.438354,  724.077698,  767.133606,  812.749756,  861.078369,  912.280762, 966.527771,
+    1024.000488, 1084.890747, 1149.401733, 1217.748657, 1290.159790, 1366.876709, 1448.155396, 1534.267212,
+};
+static float tonedown_tab[128] = {
+    1.000000, 0.943874, 0.890899, 0.840897, 0.793700, 0.749153, 0.707107, 0.667419, 0.629960, 0.594604, 0.561231, 0.529732, 0.500000,
+    0.471937, 0.445449, 0.420448, 0.396851, 0.374577, 0.353553, 0.333710, 0.314981, 0.297301, 0.280616, 0.264866, 0.250000, 0.235969,
+    0.222725, 0.210224, 0.198425, 0.187288, 0.176777, 0.166855, 0.157490, 0.148651, 0.140307, 0.132433, 0.125000, 0.117984, 0.111362,
+    0.105112, 0.099213, 0.093644, 0.088388, 0.083427, 0.078745, 0.074326, 0.070154, 0.066216, 0.062500, 0.058992, 0.055681, 0.052556,
+    0.049606, 0.046823, 0.044194, 0.041714, 0.039372, 0.037163, 0.035077, 0.033108, 0.031250, 0.029496, 0.027841, 0.026278, 0.024803,
+    0.023411, 0.022097, 0.020857, 0.019687, 0.018581, 0.017538, 0.016554, 0.015625, 0.014748, 0.013920, 0.013139, 0.012402, 0.011705,
+    0.011048, 0.010428, 0.009843, 0.009291, 0.008769, 0.008277, 0.007812, 0.007374, 0.006960, 0.006570, 0.006201, 0.005853, 0.005525,
+    0.005215, 0.004922, 0.004645, 0.004385, 0.004139, 0.003906, 0.003687, 0.003480, 0.003284, 0.003100, 0.002927, 0.002762, 0.002607,
+    0.002460, 0.002322, 0.002192, 0.002069, 0.001953, 0.001843, 0.001740, 0.001642, 0.001550, 0.001463, 0.001381, 0.001304, 0.001230,
+    0.001162, 0.001096, 0.001035, 0.000977, 0.000922, 0.000870, 0.000821, 0.000775, 0.000731, 0.000690, 0.000651,
+};
+
+s32 sndPitchUpOne(u16 note) { return note * 1.059463f; }
 
 /* non-matching https://decomp.me/scratch/6pRdi */
-u32 sndGetPitch(u8 a, u32 b) {
-    f32 var_f0;
-    u32 temp_r6;
+u32 sndGetPitch(u8 arg0, u32 arg1) {
+  f32 var_f0;
+  float scale;
+  u32 temp_r6;
+  float freq;
 
-    if (arg1 == 0xFFFFFFFF) {
-        arg1 = 0x40005622;
-    }
-    temp_r6 = arg1 >> 0x18U;
-    if (arg0 == temp_r6) {
-        var_f0 = (f32) ((arg1 & 0xFFFFFF) * (temp_r6 < arg0  ? toneup_map[(arg0 - temp_r6)] : tonedown_tab[temp_r6 - arg0]));
-    } else {
-        var_f0 = (f32) (arg1 & 0xFFFFFF);
-    }
-    return (u32) ((4096.f * var_f0) / synthInfo.freq);
+  if (arg1 == 0xFFFFFFFF) {
+    arg1 = 0x40005622;
+  }
+  scale = 4096.f;
+  temp_r6 = (arg1 >> 0x18U);
+  if (arg0 != temp_r6) {
+    var_f0 = (f32)((arg1 & 0xFFFFFF) * (temp_r6 < arg0 ? toneup_tab[(arg0 - temp_r6)] : tonedown_tab[temp_r6 - arg0]));
+  } else {
+    var_f0 = (f32)(arg1 & 0xFFFFFF);
+  }
+  scale *= var_f0;
+  return (u32)(scale / synthInfo.freq);
 }