Various imps

include/Dolphin/ai.h

@@ -0,0 +1,36 @@
+#ifndef __AI_H__
+#define __AI_H__
+
+#include "types.h"
+
+typedef void (*AISCallback)(u32 count);
+typedef void (*AIDCallback)();
+
+AIDCallback AIRegisterDMACallback(AIDCallback callback);
+void AIInitDMA(u32 start_addr, u32 length);
+BOOL AIGetDMAEnableFlag();
+void AIStartDMA();
+void AIStopDMA();
+u32 AIGetDMABytesLeft();
+u32 AIGetDMAStartAddr();
+u32 AIGetDMALength();
+u32 AIGetDSPSampleRate();
+void AISetDSPSampleRate(u32 rate);
+AISCallback AIRegisterStreamCallback(AISCallback callback);
+u32 AIGetStreamSampleCount();
+void AIResetStreamSampleCount();
+void AISetStreamTrigger(u32 trigger);
+u32 AIGetStreamTrigger();
+void AISetStreamPlayState(u32 state);
+u32 AIGetStreamPlayState();
+void AISetStreamSampleRate(u32 rate);
+u32 AIGetStreamSampleRate();
+void AISetStreamVolLeft(u8 vol);
+void AISetStreamVolRight(u8 vol);
+u8 AIGetStreamVolLeft();
+u8 AIGetStreamVolRight();
+void AIInit(u8* stack);
+BOOL AICheckInit();
+void AIReset();
+
+#endif // __AI_H__

include/Dolphin/card.h

@@ -0,0 +1,168 @@
+#ifndef __CARD_H__
+#define __CARD_H__
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define CARD_ENCODE_ANSI 0u
+#define CARD_ENCODE_SJIS 1u
+
+/* Sizes */
+#define CARD_WORKAREA_SIZE (5 * 8 * 1024)
+#define CARD_READ_SIZE 512
+#define CARD_MAX_FILE 127
+#define CARD_COMMENT_SIZE 64
+#define CARD_FILENAME_MAX 32
+#define CARD_ICON_MAX 8
+#define CARD_ICON_WIDTH 32
+#define CARD_ICON_HEIGHT 32
+#define CARD_BANNER_WIDTH 96
+#define CARD_BANNER_HEIGHT 32
+
+/* Icon animation */
+#define CARD_MODE_NORMAL 0
+#define CARD_MODE_FAST 1
+
+#define CARDGetBannerFormat(stat) (((stat)->bannerFormat) & CARD_STAT_BANNER_MASK)
+#define CARDGetIconAnim(stat) (((stat)->bannerFormat) & CARD_STAT_ANIM_MASK)
+#define CARDGetIconFormat(stat, n) (((stat)->iconFormat >> (2 * (n))) & CARD_STAT_ICON_MASK)
+#define CARDGetIconSpeed(stat, n) (((stat)->iconSpeed >> (2 * (n))) & CARD_STAT_SPEED_MASK)
+#define CARDSetBannerFormat(stat, f) ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_BANNER_MASK) | (f)))
+#define CARDSetIconAnim(stat, f) ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_ANIM_MASK) | (f)))
+#define CARDSetIconFormat(stat, n, f)                                                                                                      \
+  ((stat)->iconFormat = (u16)(((stat)->iconFormat & ~(CARD_STAT_ICON_MASK << (2 * (n)))) | ((f) << (2 * (n)))))
+#define CARDSetIconSpeed(stat, n, f)                                                                                                       \
+  ((stat)->iconSpeed = (u16)(((stat)->iconSpeed & ~(CARD_STAT_SPEED_MASK << (2 * (n)))) | ((f) << (2 * (n)))))
+#define CARDSetIconAddress(stat, addr) ((stat)->iconAddr = (u32)(addr))
+#define CARDSetCommentAddress(stat, addr) ((stat)->commentAddr = (u32)(addr))
+#define CARDGetFileNo(fileInfo) ((fileInfo)->fileNo)
+
+#define CARD_RESULT_UNLOCKED 1
+#define CARD_RESULT_READY 0
+#define CARD_RESULT_BUSY -1
+#define CARD_RESULT_WRONGDEVICE -2
+#define CARD_RESULT_NOCARD -3
+#define CARD_RESULT_NOFILE -4
+#define CARD_RESULT_IOERROR -5
+#define CARD_RESULT_BROKEN -6
+#define CARD_RESULT_EXIST -7
+#define CARD_RESULT_NOENT -8
+#define CARD_RESULT_INSSPACE -9
+#define CARD_RESULT_NOPERM -10
+#define CARD_RESULT_LIMIT -11
+#define CARD_RESULT_NAMETOOLONG -12
+#define CARD_RESULT_ENCODING -13
+#define CARD_RESULT_CANCELED -14
+#define CARD_RESULT_FATAL_ERROR -128
+
+#define CARD_STAT_ICON_NONE 0
+#define CARD_STAT_ICON_C8 1
+#define CARD_STAT_ICON_RGB5A3 2
+#define CARD_STAT_ICON_MASK 3
+
+#define CARD_STAT_BANNER_NONE 0
+#define CARD_STAT_BANNER_C8 1
+#define CARD_STAT_BANNER_RGB5A3 2
+#define CARD_STAT_BANNER_MASK 3
+
+#define CARD_STAT_ANIM_LOOP 0x00
+#define CARD_STAT_ANIM_BOUNCE 0x04
+#define CARD_STAT_ANIM_MASK 0x04
+
+#define CARD_STAT_SPEED_END 0
+#define CARD_STAT_SPEED_FAST 1
+#define CARD_STAT_SPEED_MIDDLE 2
+#define CARD_STAT_SPEED_SLOW 3
+#define CARD_STAT_SPEED_MASK 3
+
+#define CARD_ATTR_PUBLIC 0x04u
+#define CARD_ATTR_NO_COPY 0x08u
+#define CARD_ATTR_NO_MOVE 0x10u
+#define CARD_ATTR_GLOBAL 0x20u
+#define CARD_ATTR_COMPANY 0x40u
+
+typedef struct CARDFileInfo {
+  s32 chan;
+  s32 fileNo;
+
+  s32 offset;
+  s32 length;
+  u16 iBlock;
+  u16 __padding;
+} CARDFileInfo;
+
+typedef struct CARDStat {
+  char fileName[CARD_FILENAME_MAX];
+  u32 length;
+  u32 time; // seconds since 01/01/2000 midnight
+  u8 gameName[4];
+  u8 company[2];
+
+  u8 bannerFormat;
+  u8 __padding;
+  u32 iconAddr; // offset to the banner, bannerTlut, icon, iconTlut data set.
+  u16 iconFormat;
+  u16 iconSpeed;
+  u32 commentAddr; // offset to the pair of 32 byte character strings.
+
+  u32 offsetBanner;
+  u32 offsetBannerTlut;
+  u32 offsetIcon[CARD_ICON_MAX];
+  u32 offsetIconTlut;
+  u32 offsetData;
+} CARDStat;
+
+typedef void (*CARDCallback)(s32 chan, s32 result);
+
+void CARDInit(void);
+BOOL CARDGetFastMode(void);
+BOOL CARDSetFastMode(BOOL enable);
+
+s32 CARDCheck(s32 chan);
+s32 CARDCheckAsync(s32 chan, CARDCallback callback);
+s32 CARDCheckEx(s32 chan, s32* xferBytes);
+s32 CARDCheckExAsync(s32 chan, s32* xferBytes, CARDCallback callback);
+s32 CARDCreate(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo);
+s32 CARDCreateAsync(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo, CARDCallback callback);
+s32 CARDDelete(s32 chan, const char* fileName);
+s32 CARDDeleteAsync(s32 chan, const char* fileName, CARDCallback callback);
+s32 CARDFastDelete(s32 chan, s32 fileNo);
+s32 CARDFastDeleteAsync(s32 chan, s32 fileNo, CARDCallback callback);
+s32 CARDFastOpen(s32 chan, s32 fileNo, CARDFileInfo* fileInfo);
+s32 CARDFormat(s32 chan);
+s32 CARDFormatAsync(s32 chan, CARDCallback callback);
+s32 CARDFreeBlocks(s32 chan, s32* byteNotUsed, s32* filesNotUsed);
+s32 CARDGetAttributes(s32 chan, s32 fileNo, u8* attr);
+s32 CARDGetEncoding(s32 chan, u16* encode);
+s32 CARDGetMemSize(s32 chan, u16* size);
+s32 CARDGetResultCode(s32 chan);
+s32 CARDGetSectorSize(s32 chan, u32* size);
+s32 CARDGetSerialNo(s32 chan, u64* serialNo);
+s32 CARDGetStatus(s32 chan, s32 fileNo, CARDStat* stat);
+s32 CARDGetXferredBytes(s32 chan);
+s32 CARDMount(s32 chan, void* workArea, CARDCallback detachCallback);
+s32 CARDMountAsync(s32 chan, void* workArea, CARDCallback detachCallback, CARDCallback attachCallback);
+s32 CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo);
+BOOL CARDProbe(s32 chan);
+s32 CARDProbeEx(s32 chan, s32* memSize, s32* sectorSize);
+s32 CARDRename(s32 chan, const char* oldName, const char* newName);
+s32 CARDRenameAsync(s32 chan, const char* oldName, const char* newName, CARDCallback callback);
+s32 CARDSetAttributesAsync(s32 chan, s32 fileNo, u8 attr, CARDCallback callback);
+s32 CARDSetAttributes(s32 chan, s32 fileNo, u8 attr);
+s32 CARDSetStatus(s32 chan, s32 fileNo, CARDStat* stat);
+s32 CARDSetStatusAsync(s32 chan, s32 fileNo, CARDStat* stat, CARDCallback callback);
+s32 CARDUnmount(s32 chan);
+s32 CARDGetCurrentMode(s32 chan, u32* mode);
+s32 CARDCancel(CARDFileInfo* fileInfo);
+s32 CARDClose(CARDFileInfo* fileInfo);
+s32 CARDRead(CARDFileInfo* fileInfo, void* addr, s32 length, s32 offset);
+s32 CARDReadAsync(CARDFileInfo* fileInfo, void* addr, s32 length, s32 offset, CARDCallback callback);
+s32 CARDWrite(CARDFileInfo* fileInfo, const void* addr, s32 length, s32 offset);
+s32 CARDWriteAsync(CARDFileInfo* fileInfo, const void* addr, s32 length, s32 offset, CARDCallback callback);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // __CARD_H__

include/Dolphin/dsp_regs.h

@@ -4,5 +4,6 @@
 #include "types.h"
 
 vu16 __DSPRegs[32] : 0xCC005000;
+vu32 __AIRegs[8]   : 0xCC006C00;
 
 #endif // __DSP_REGS_H__

include/Dolphin/os.h

@@ -7,19 +7,32 @@
 extern "C" {
 #endif
 
-// #ifndef ADDRESS
-// #define ADDRESS(v) __attribute__((address((v))))
-// #endif
-// const u32 __OSBusClock ADDRESS(0x800000f8);
-// const u32 __OSCoreClock ADDRESS(0x800000fc);
-// #define OS_BUS_CLOCK __OSBusClock
-// #define OS_CORE_CLOCK __OSCoreClock
+// Upper words of the masks, since UIMM is only 16 bits
+#define OS_CACHED_REGION_PREFIX         0x8000
+#define OS_UNCACHED_REGION_PREFIX       0xC000
+#define OS_PHYSICAL_MASK                0x3FFF
 
-#define OS_BUS_CLOCK *((const u32*)0x800000f8)
-#define OS_CORE_CLOCK *((const u32*)0x800000fc)
-#define OS_TIMER_CLOCK (OS_BUS_CLOCK / 4)
+#define OS_BASE_CACHED                  (OS_CACHED_REGION_PREFIX << 16)
+#define OS_BASE_UNCACHED                (OS_UNCACHED_REGION_PREFIX << 16)
 
-#define OSSecondsToTicks(v) ((v)*OS_TIMER_CLOCK)
+#define AT_ADDRESS(xyz) : (xyz)
+u32 __OSBusClock    AT_ADDRESS(OS_BASE_CACHED | 0x00F8);    // sync with OSLoMem.h
+u32 __OSCoreClock   AT_ADDRESS(OS_BASE_CACHED | 0x00FC);    // sync with OSLoMem.h
+#define OS_BUS_CLOCK        __OSBusClock
+#define OS_CORE_CLOCK       __OSCoreClock
+#define OS_TIMER_CLOCK      (OS_BUS_CLOCK/4)
+
+#define OSTicksToCycles( ticks )        (((ticks) * ((OS_CORE_CLOCK * 2) / OS_TIMER_CLOCK)) / 2)
+#define OSTicksToSeconds( ticks )       ((ticks) / OS_TIMER_CLOCK)
+#define OSTicksToMilliseconds( ticks )  ((ticks) / (OS_TIMER_CLOCK / 1000))
+#define OSTicksToMicroseconds( ticks )  (((ticks) * 8) / (OS_TIMER_CLOCK / 125000))
+#define OSTicksToNanoseconds( ticks )   (((ticks) * 8000) / (OS_TIMER_CLOCK / 125000))
+#define OSSecondsToTicks( sec )         ((sec)  * OS_TIMER_CLOCK)
+#define OSMillisecondsToTicks( msec )   ((msec) * (OS_TIMER_CLOCK / 1000))
+#define OSMicrosecondsToTicks( usec )   (((usec) * (OS_TIMER_CLOCK / 125000)) / 8)
+#define OSNanosecondsToTicks( nsec )    (((nsec) * (OS_TIMER_CLOCK / 125000)) / 8000)
+
+#define OSDiffTick(tick1, tick0)        ((s32) (tick1) - (s32) (tick0))
 
 
 typedef struct OSContext {

include/MetroidPrime/CObjectList.hpp

@@ -0,0 +1,46 @@
+#ifndef __COBJECTLIST_HPP__
+#define __COBJECTLIST_HPP__
+
+#define kMaxObjects 1024
+enum EGameObjectList {
+  kGOL_Invalid = -1,
+  kGOL_All,
+  kGOL_Actor,
+  kGOL_PhysicsActor,
+  kGOL_GameCamera,
+  kGOL_GameLight,
+  kGOL_ListeningAi,
+  kGOL_AiWaypoint,
+  kGOL_PlatformAndDoor,
+};
+
+class CEntity;
+class CObjectList {
+  struct SObjectListEntry {
+    CEntity* mEnt;
+    s16 mNext;
+    s16 mPrev;
+    SObjectListEntry();
+  };
+
+public:
+  CObjectList(EGameObjectList list);
+  bool IsQualified(CEntity& ent);  
+  void AddObject(CEntity& ent);
+  void RemoveObject(TUniqueId uid);
+  CEntity* GetObjectById();
+  const CEntity* GetObjectById() const;
+  CEntity* GetValidObjectById(TUniqueId uid);
+  const CEntity* GetValidObjectById(TUniqueId uid) const;
+  CEntity* operator[](s32 idx);
+  const CEntity* operator[](s32 idx) const;
+  const CEntity* GetValidObjectByIndex(s32 idx) const;
+  s32 size() const { return mCount; }
+private:
+  SObjectListEntry mObjects[1024];
+  EGameObjectList mListType;
+  s16 mFirstId = -1;
+  s16 mCount = 0;
+}
+
+#endif // __COBJECTLIST_HPP__

include/MetroidPrime/Cameras/CBallCamera.hpp

@@ -0,0 +1,32 @@
+#ifndef __CBALLCAMERA_HPP__
+#define __CBALLCAMERA_HPP__
+
+class CBallCamera {
+public:
+  enum EBallCameraState {
+    kBCS_Default,
+    kBCS_One,
+    kBCS_Chase,
+    kBCS_Boost,
+    kBCS_ToBall,
+    kBCS_FromBall,
+  };
+  enum EBallCameraBehaviour {
+    kBCB_Default,
+    kBCB_FreezeLookPosition, // Unused
+    kBCB_HintBallToCam,
+    kBCB_HintInitializePosition,
+    kBCB_HintFixedPosition,
+    kBCB_HintFixedTransform,
+    kBCB_PathCameraDesiredPos, // Unused
+    kBCB_PathCamera,
+    kBCB_SpindleCamera,
+  };
+  enum ESplineState {
+    kSS_Invalid,
+    kSS_Nav,
+    kSS_Arc,
+  };
+};
+
+#endif // __CBALLCAMERA_HPP__

include/MetroidPrime/Cameras/CCameraHint.hpp

@@ -0,0 +1,38 @@
+#ifndef __CCAMERAHINT_HPP__
+#define __CCAMERAHINT_HPP__
+
+#include "types.h"
+#include "MetroidPrime/Cameras/CBallCamera.hpp"
+#include "Kyoto/Math/CVector3f.hpp"
+
+class CCameraHint {
+public:
+  CCameraHint(u32 overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, f32 minDist, f32 maxDist,
+              f32 backwardsDist, const CVector3f& lookAtOffset, const CVector3f& chaseLookAtOffset,
+              const CVector3f& ballToCam, f32 fov, f32 attitudeRange, f32 azimuthRange,
+              f32 anglePerSecond, f32 clampVelRange, f32 clampRotRange, f32 elevation, f32 interpolateTime,
+              f32 clampVelTime, f32 controlInterpDur);
+  virtual ~CCameraHint();
+  
+private:
+  u32 mOverrideFlags;
+  CBallCamera::EBallCameraBehaviour mBehaviour;
+  f32 mMinDist;
+  f32 mMaxDist;
+  f32 mBackwardsDist;
+  CVector3f mLookAtOffset;
+  CVector3f mChaseLookAtOffset;
+  CVector3f mBallToCam;
+  f32 mFov;
+  f32 mAttitudeRange;
+  f32 mAzimuthRange;
+  f32 mAnglePerSecond;
+  f32 mClampVelRange;
+  f32 mClampRotRange;
+  f32 mElevation;
+  f32 mInterpolateTime;
+  f32 mClampVelTime;
+  f32 mControlInterpDur;
+};
+
+#endif // __CCAMERAHINT_HPP__

include/musyx/musyx.h

@@ -12,7 +12,8 @@ extern "C" {
 #endif
 
 typedef struct _SynthInfo {
-  u8 unk[0x210];
+  u32 freq;
+  u8 unk[0x20c];
   u8 voices;
   u8 music;
   u8 sfx;

include/types.h

@@ -36,6 +36,7 @@ typedef u32 uintptr_t;
 
 typedef s16  __OSInterrupt;
 typedef s64 OSTime;
+typedef u32 OSTick;
 
 // Pointer to unknown, to be determined at a later date.
 typedef void* unkptr;