MGislv
/
ooot
mirror of https://github.com/blawar/ooot.git
1
0
Fork 0
Code Releases Wiki Activity

formatting

This commit is contained in:
Blake Warner 2022-04-08 17:48:33 -04:00
parent 5cd0585024
commit 7258c27df1
1311 changed files with 352775 additions and 312847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.clang-format
View File

@ -45,9 +45,32 @@ SpacesInCStyleCastParentheses: 'false'
SpacesInParentheses: 'false'
SpacesInSquareBrackets: 'false'
Standard: Cpp11
SortIncludes: 'true'
TabWidth: '8'
IndentWidth: '8'
UseTab: Always
SortIncludes: 'false'
IncludeCategories:
# global header
- Regex: '"global.h"'
Priority: -100
# global header
- Regex: '"(gfx.h|z64global.h)"'
Priority: -98
# Headers in <>
- Regex: '<(.)+>'
Priority: -96
# Headers in def
- Regex: '"def/(.)+"'
Priority: -70
# Headers in relative paths
- Regex: '"\.\.(.)+"'
Priority: -92
# Headers in def
- Regex: '"objects/(.)+"'
Priority: -60
# Headers in ""
- Regex: '"(.)+"'
Priority: -80
...

31
format.sh
View File

@ -1,29 +1,4 @@
#!/usr/bin/env bash
FORMAT_OPTS="-i -style=file"
TIDY_OPTS="-p . --fix --fix-errors"
COMPILER_OPTS="-fno-builtin -std=gnu90 -Iinclude -Isrc -D_LANGUAGE_C -DNON_MATCHING"
shopt -s globstar
if (( $# > 0 )); then
echo "Formatting file(s) $*"
echo "Running clang-format..."
clang-format ${FORMAT_OPTS} "$@"
echo "Running clang-tidy..."
clang-tidy ${TIDY_OPTS} "$@" -- ${COMPILER_OPTS} &> /dev/null
echo "Adding missing final new lines..."
sed -i -e '$a\' "$@"
echo "Done formatting file(s) $*"
exit
fi
echo "Formatting C files. This will take a bit"
echo "Running clang-format..."
clang-format ${FORMAT_OPTS} src/**/*.c
echo "Running clang-tidy..."
clang-tidy ${TIDY_OPTS} src/**/*.c -- ${COMPILER_OPTS} &> /dev/null
echo "Adding missing final new lines..."
find src/ -type f -name "*.c" -exec sed -i -e '$a\' {} \;
find assets/xml/ -type f -name "*.xml" -exec sed -i -e '$a\' {} \;
echo "Done formatting all files."
find src/ iname '*.cpp' -exec clang-format -i -style=file "{}" \;
find src/ iname '*.h' -exec clang-format -i -style=file "{}" \;
find include/ iname '*.h' -exec clang-format -i -style=file "{}" \;

14
include/actor_common.h
View File

@ -1,14 +1,12 @@
#pragma once
#include "global.h"
#include "z64global.h"
#include "ichain.h"
#include "player_state.h"
#include "sequence.h"
#include "sfx.h"
#include "z64effect.h"
#include "z64item.h"
#include "z64player.h"
#include "z64save.h"
#include "z64item.h"
#include "ichain.h"
#include "sfx.h"
#include "sequence.h"
#include "z64effect.h"
#include "def/graph.h" // FORCE
#include "player_state.h"

5
include/asset_common.h
View File

@ -1,7 +1,6 @@
#pragma once
#include "z64actor.h"
#include "z64animation.h"
#include "z64bgcheck.h"
#include "z64actor.h"
#include "z64scene.h"
#include "z64object.h"
#include "z64scene.h"

44
include/audiomgr.h
View File

@ -1,32 +1,34 @@
#pragma once
#include "framerate.h"
#include "ultra64/sched.h"
#include "z64math.h"
#include "framerate.h"
struct AudioTask;
struct SoundSource {
/* 0x00 */ Timer countdown;
/* 0x04 */ Vec3f originPos;
/* 0x10 */ Vec3f relativePos;
struct SoundSource
{
/* 0x00 */ Timer countdown;
/* 0x04 */ Vec3f originPos;
/* 0x10 */ Vec3f relativePos;
}; // size = 0x1C
struct AudioMgr {
/* 0x0000 */ IrqMgr* irqMgr;
/* 0x0004 */ SchedContext* sched;
/* 0x0008 */ OSScTask audioTask;
/* 0x0060 */ char unk_60[0x10];
/* 0x0070 */ AudioTask* rspTask;
/* 0x0074 */ OSMesgQueue unk_74;
/* 0x008C */ OSMesg unk_8C;
/* 0x0090 */ OSMesgQueue unk_90;
/* 0x00A8 */ OSMesg unk_A8;
/* 0x00AC */ OSMesgQueue unk_AC;
/* 0x00C4 */ OSMesg unk_C4;
/* 0x00C8 */ OSMesgQueue unk_C8;
/* 0x00E0 */ OSMesg unk_E0;
/* 0x00E4 */ char unk_E4[0x04];
/* 0x00E8 */ OSThread unk_E8;
struct AudioMgr
{
/* 0x0000 */ IrqMgr* irqMgr;
/* 0x0004 */ SchedContext* sched;
/* 0x0008 */ OSScTask audioTask;
/* 0x0060 */ char unk_60[0x10];
/* 0x0070 */ AudioTask* rspTask;
/* 0x0074 */ OSMesgQueue unk_74;
/* 0x008C */ OSMesg unk_8C;
/* 0x0090 */ OSMesgQueue unk_90;
/* 0x00A8 */ OSMesg unk_A8;
/* 0x00AC */ OSMesgQueue unk_AC;
/* 0x00C4 */ OSMesg unk_C4;
/* 0x00C8 */ OSMesgQueue unk_C8;
/* 0x00E0 */ OSMesg unk_E0;
/* 0x00E4 */ char unk_E4[0x04];
/* 0x00E8 */ OSThread unk_E8;
}; // size = 0x298
extern Vec3f gAudioDefaultPos;

12
include/code_800ACE70.h
View File

@ -1,10 +1,10 @@
#pragma once
// Vis...
struct struct_801664F0 {
/* 0x00 */ u32 type;
/* 0x04 */ u32 setScissor;
/* 0x08 */ Color_RGBA8 color;
/* 0x0C */ Color_RGBA8 envColor;
struct struct_801664F0
{
/* 0x00 */ u32 type;
/* 0x04 */ u32 setScissor;
/* 0x08 */ Color_RGBA8 color;
/* 0x0C */ Color_RGBA8 envColor;
}; // size = 0x10

48
include/color.h
View File

@ -1,32 +1,40 @@
#pragma once
#include "macros.h"
#include "porting_defs.h"
struct Color_RGB8 {
u8 r, g, b;
struct Color_RGB8
{
u8 r, g, b;
};
struct Color_RGBA8 {
Color_RGBA8() = default;
Color_RGBA8(u8 r_, u8 g_, u8 b_, u8 a_) : r(r_), g(g_), b(b_), a(a_) {}
struct Color_RGBA8
{
Color_RGBA8() = default;
Color_RGBA8(u8 r_, u8 g_, u8 b_, u8 a_) : r(r_), g(g_), b(b_), a(a_)
{
}
explicit operator u32 () {
return BE32(RGBA8(r, g, b, a));
}
explicit operator u32()
{
return BE32(RGBA8(r, g, b, a));
}
u8 r, g, b, a;
u8 r, g, b, a;
};
struct Color_RGBAf {
f32 r, g, b, a;
struct Color_RGBAf
{
f32 r, g, b, a;
};
typedef union {
struct {
u16 r : 5;
u16 g : 5;
u16 b : 5;
u16 a : 1;
};
u16 rgba;
typedef union
{
struct
{
u16 r : 5;
u16 g : 5;
u16 b : 5;
u16 a : 1;
};
u16 rgba;
} Color_RGBA16;

18
include/command_macros_base.h
View File

@ -19,8 +19,7 @@
#if IS_BIG_ENDIAN
#if IS_64_BIT
#define CMD_BBBB(a, b, c, d) \
((uintptr_t)(_SHIFTL(a, 24, 8) | _SHIFTL(b, 16, 8) | _SHIFTL(c, 8, 8) | _SHIFTL(d, 0, 8)) << 32)
#define CMD_BBBB(a, b, c, d) ((uintptr_t)(_SHIFTL(a, 24, 8) | _SHIFTL(b, 16, 8) | _SHIFTL(c, 8, 8) | _SHIFTL(d, 0, 8)) << 32)
#define CMD_BBH(a, b, c) ((uintptr_t)(_SHIFTL(a, 24, 8) | _SHIFTL(b, 16, 8) | _SHIFTL(c, 0, 16)) << 32)
#define CMD_HH(a, b) ((uintptr_t)(_SHIFTL(a, 16, 16) | _SHIFTL(b, 0, 16)) << 32)
#define CMD_W(a) ((uintptr_t)(a) << 32)
@ -48,12 +47,21 @@
#endif
#ifdef __GNUC__
#define CMD_F(a) {.f = (a)}
#define CMD_F(a) \
{ \
.f = (a) \
}
#else
#ifdef _MSC_VER
#define CMD_F(a) {.f = (a)}
#define CMD_F(a) \
{ \
.f = (a) \
}
#else
#define CMD_F(a) {(a)}
#define CMD_F(a) \
{ \
(a) \
}
#endif
#endif

6
include/def/audio_data.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "z64audio.h"
struct AdsrEnvelope;
extern s16 D_8012FBA8[];
@ -15,5 +17,5 @@ extern f32 gNoteFrequencies[];
extern f32 gStereoPanVolume[128];
extern s16* gWaveSamples[9];
extern NoteSubEu gZeroNoteSub;
extern s16 sHighPassFilterData[15*8];
extern s16 sLowPassFilterData[16*8];
extern s16 sHighPassFilterData[15 * 8];
extern s16 sLowPassFilterData[16 * 8];

1
include/def/audio_effects.h
View File

@ -5,6 +5,7 @@ struct VibratoState;
struct Note;
struct SequenceChannel;
struct SequencePlayer;
struct AdsrState;
void Audio_AdsrInit(AdsrState* adsr, AdsrEnvelope* envelope, s16* volOut);
f32 Audio_AdsrUpdate(AdsrState* adsr);

2
include/def/audio_load.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "z64audio.h"
struct OSMesgQueue;
extern s32 gAudioContextInitalized;

3
include/def/audio_playback.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "ultra64/types.h"
struct SequenceLayer;
struct Note;
struct NotePool;
@ -7,6 +9,7 @@ struct Drum;
struct Instrument;
struct SoundFontSound;
struct NoteSubAttributes;
struct NoteSubEu;
Note* Audio_AllocNote(SequenceLayer* layer);
Note* Audio_AllocNoteFromActive(NotePool* pool, SequenceLayer* layer);

36
include/def/audio_rsp.h
View File

@ -39,26 +39,26 @@ enum ChannelUpdateType
enum LoadChannelType
{
CHAN_LOAD_SET_SOUND_MODE = 0xF0,
CHAN_LOAD_UKN_F1 = 0xF1,
CHAN_LOAD_UKN_F2 = 0xF2,
CHAN_LOAD_INSTRUMENT_ASYNC = 0xF3,
CHAN_LOAD_BANK_ASYNC = 0xF4,
CHAN_LOAD_FONT_ASYNC = 0xF5,
CHAN_LOAD_DISCARD_SEQ_FONTS = 0xF6,
CHAN_LOAD_UKN_FC = 0xFC,
CHAN_LOAD_UKN_81 = 0x81,
CHAN_LOAD_UKN_82 = 0x82,
CHAN_LOAD_DISABLE_SEQUENCE = 0x83,
CHAN_LOAD_UKN_85 = 0x85,
CHAN_LOAD_UKN_90 = 0x90,
CHAN_LOAD_SET_SOUND_MODE = 0xF0,
CHAN_LOAD_UKN_F1 = 0xF1,
CHAN_LOAD_UKN_F2 = 0xF2,
CHAN_LOAD_INSTRUMENT_ASYNC = 0xF3,
CHAN_LOAD_BANK_ASYNC = 0xF4,
CHAN_LOAD_FONT_ASYNC = 0xF5,
CHAN_LOAD_DISCARD_SEQ_FONTS = 0xF6,
CHAN_LOAD_UKN_FC = 0xFC,
CHAN_LOAD_UKN_81 = 0x81,
CHAN_LOAD_UKN_82 = 0x82,
CHAN_LOAD_DISABLE_SEQUENCE = 0x83,
CHAN_LOAD_UKN_85 = 0x85,
CHAN_LOAD_UKN_90 = 0x90,
CHAN_LOAD_SET_FONT_INSTRUMENT0 = 0xE0,
CHAN_LOAD_SET_FONT_INSTRUMENT1 = 0xE1,
CHAN_LOAD_SET_FONT_INSTRUMENT = 0xE2,
CHAN_LOAD_POP_CACHE = 0xE3,
CHAN_LOAD_RESET_LOAD_SPECID = 0xF9,
CHAN_LOAD_UKN_FB_CALLBACK = 0xFB,
CHAN_LOAD_UKN_FE = 0xFE
CHAN_LOAD_SET_FONT_INSTRUMENT = 0xE2,
CHAN_LOAD_POP_CACHE = 0xE3,
CHAN_LOAD_RESET_LOAD_SPECID = 0xF9,
CHAN_LOAD_UKN_FB_CALLBACK = 0xFB,
CHAN_LOAD_UKN_FE = 0xFE
};
enum SequenceCommandType

1
include/def/code_800AD920.h
View File

@ -1,5 +1,6 @@
#pragma once
struct struct_80166500;
union Gfx;
void func_800AD920(struct_80166500* pthis);
void func_800AD950(struct_80166500* pthis);

2
include/def/gfxbuffers.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "ultra64/sptask.h"
struct GfxPool;
extern GfxPool gGfxPools[2];

1
include/def/heaps.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "ultra64/types.h"
extern u8 gAudioHeap[0x38000];
extern u8 gSystemHeap[];

1
include/def/initialize.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "ultra64/exception.h"
extern OSHWIntr __OSGlobalIntMask;
extern u32 __osShutdown;

2
include/def/inventory.h
View File

@ -9,7 +9,7 @@ extern u32 gGsFlagsMasks[4];
extern u32 gGsFlagsShifts[4];
extern void* gItemIcons[0x82];
extern void* gItemIconsCurrent[86];
extern void* gItemIconsGray[86][32*32];
extern void* gItemIconsGray[86][32 * 32];
extern u8 gItemSlots[56];
extern u16 gUpgradeCapacities[8][4];
extern u32 gUpgradeMasks[8];

2
include/def/irqmgr.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "ultra64/time.h"
struct IrqMgr;
struct IrqMgrClient;
struct OSMesgQueue;

1
include/def/printutils.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "ultra64/printf.h"
s32 PrintUtils_Printf(PrintCallback* pfn, const char* fmt, ...);
s32 PrintUtils_VPrintf(PrintCallback* pfn, const char* fmt, va_list args);

1
include/def/recvmesg.h
View File

@ -1,2 +1 @@
#pragma once

1
include/def/sleep.h
View File

@ -1,4 +1,5 @@
#pragma once
#include "ultra64/time.h"
void Sleep_Cycles(OSTime cycles);
void Sleep_Msec(u32 ms);

3
include/def/z_actor.h
View File

@ -203,6 +203,3 @@ void func_800359B8(Actor* actor, s16 arg1, VecRot* arg2);
u16 func_80037C30(GlobalContext* globalCtx, s16 arg1);
s32 func_80037D98(GlobalContext* globalCtx, Actor* actor, s16 arg2, s32* arg3);
s32 func_80038290(GlobalContext* globalCtx, Actor* actor, Vec3s* arg2, Vec3s* arg3, Vec3f arg4);

2
include/def/z_camera.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "unk.h"
struct Camera;
struct Actor;
struct Vec3s;

1
include/def/z_fbdemo.h
View File

@ -1,5 +1,6 @@
#pragma once
struct TransitionUnk;
union Gfx;
void TransitionUnk_Destroy(TransitionUnk* pthis);
void TransitionUnk_Draw(TransitionUnk* pthis, Gfx**);

2
include/def/z_kaleido_manager.h
View File

@ -1,4 +1,6 @@
#pragma once
#include "kaleido.h"
struct KaleidoMgrOverlay;
struct GlobalContext;

1
include/def/zbuffer.h
View File

@ -1,3 +1,4 @@
#pragma once
#include "z64.h"
extern u16 gZBuffer[SCREEN_HEIGHT][SCREEN_WIDTH];

15
include/framerate.h
View File

@ -53,16 +53,17 @@ typedef enum
#define FRAMERATE_RATE_SCALED ((R_UPDATE_RATE / FRAMERATE_RATE_SCALER) < 1 ? 1 : (R_UPDATE_RATE / FRAMERATE_RATE_SCALER))
#define FRAME_TIME (1.0f / (float)FRAME_RATE)
typedef enum{
typedef enum
{
PROFILE_BOOT = 0, // 30FPS
PROFILE_PAUSE, // 20FPS
PROFILE_GAMEPLAY, // 20FPS
PROFILE_UNKNOWN1, // 60FPS
PROFILE_UNKNOWN2, // 60FPS
PROFILE_SAMPLE, // 60FPS
PROFILE_SAMPLE, // 60FPS
PROFILE_OPENING, // 60FPS
PROFILE_SELECT, // 60FPS
PROFILE_TITLE, // 60FPS
PROFILE_SELECT, // 60FPS
PROFILE_TITLE, // 60FPS
PROFILE_FILE_CHOOSE // 60FPS
} FramerateProfile;
@ -81,9 +82,9 @@ class Timer
static Timer invalid();
Timer& operator++(); // pre
Timer& operator++(); // pre
Timer operator++(int); // post
Timer& operator--(); // pre
Timer& operator--(); // pre
Timer operator--(int); // post
Timer& dec();
bool isWhole() const;
@ -144,5 +145,3 @@ class Step
protected:
float m_value;
};

904
include/functions.h
View File

@ -1,905 +1,5 @@
#pragma once
/*
#define POINTER_ADD(a, b) ((uintptr_t)a + (uintptr_t)b)
#define POINTER_SUB(a, b) ((uintptr_t)a - (uintptr_t)b)
struct ViMode;
struct Input;
#include "z64.h"
#include <math.h>
#ifdef __cplusplus
extern "C" {
#endif
void Main_ThreadEntry(void* arg);
void Idle_ThreadEntry(void* arg);
void ViConfig_UpdateVi(u32 mode);
void ViConfig_UpdateBlack(void);
s32 DmaMgr_CompareName(const char* name1, const char* name2);
s32 DmaMgr_DmaRomToRam(void* rom, void* ram, uintptr_t size);
s32 DmaMgr_DmaHandler(OSPiHandle* pihandle, OSIoMesg* mb, s32 direction);
void DmaMgr_Error(DmaRequest* req, const char* file, const char* errorName, const char* errorDesc);
const char* DmaMgr_GetFileNameImpl(void* vrom);
const char* DmaMgr_GetFileName(void* vrom);
void DmaMgr_ProcessMsg(DmaRequest* req);
void DmaMgr_ThreadEntry(void* arg0);
s32 DmaMgr_SendRequestImpl(DmaRequest* req, void* ram, void* vrom, uintptr_t size, u32 unk, OSMesgQueue* queue, OSMesg msg);
s32 DmaMgr_SendRequest0(void* ram, void* vrom, uintptr_t size);
void DmaMgr_Init(void);
s32 DmaMgr_SendRequest2(DmaRequest* req, void* ram, void* vrom, uintptr_t size, u32 unk5, OSMesgQueue* queue, OSMesg msg,
const char* file, s32 line);
s32 DmaMgr_SendRequest1(void* ram0, void* vrom, uintptr_t size, const char* file, s32 line);
void* Yaz0_FirstDMA(void);
void* Yaz0_NextDMA(void* curSrcPos);
void Yaz0_DecompressImpl(Yaz0Header* hdr, u8* dst);
void Yaz0_Decompress(uintptr_t romStart, void* dst, u32 size);
void Locale_Init(void);
void Locale_ResetRegion(void);
u32 func_80001F48(void);
u32 func_80001F8C(void);
u32 Locale_IsRegionNative(void);
void isPrintfInit(void);
#if defined(_IS_DEBUG) || 1
void osSyncPrintf(const char* fmt, ...);
#else
#define osSyncPrintf(a, ...) (0)
#endif
void rmonPrintf(const char* fmt, ...);
void* is_proutSyncPrintf(void* arg, const char* str, u32 count);
void func_80002384(const char* exp, const char* file, u32 line);
OSPiHandle* osDriveRomInit(void);
void Mio0_Decompress(Yaz0Header* hdr, u8* dst);
void StackCheck_Init(StackEntry* entry, void* stackTop, void* stackBottom, u32 initValue, s32 minSpace,
const char* name);
void StackCheck_Cleanup(StackEntry* entry);
StackStatus StackCheck_GetState(StackEntry* entry);
u32 StackCheck_CheckAll(void);
u32 StackCheck_Check(StackEntry* entry);
s32 vsprintf(char* dst, const char* fmt, va_list args);
s32 sprintf(char* dst, const char* fmt, ...);
void __osPiCreateAccessQueue(void);
void __osPiGetAccess(void);
void __osPiRelAccess(void);
void osStopThread(OSThread* thread);
void osViExtendVStart(u32 arg0);
s32 osRecvMesg(OSMesgQueue* mq, OSMesg* msg, s32 flag);
void __osInitialize_common(void);
void __osInitialize_autodetect(void);
void __osExceptionPreamble();
// ? __osException(?);
void __osEnqueueAndYield(OSThread**);
void __osEnqueueThread(OSThread**, OSThread*);
OSThread* __osPopThread(OSThread**);
// ? __osNop(?);
void __osDispatchThread();
void __osCleanupThread(void);
void __osDequeueThread(OSThread** queue, OSThread* thread);
void osDestroyThread(OSThread* thread);
void osCreateThread(OSThread* thread, OSId id, void (*entry)(void*), void* arg, void* sp, OSPri pri);
void __osSetSR(u32);
u32 __osGetSR();
void osWritebackDCache(void* vaddr, s32 nbytes);
void* osViGetNextFramebuffer(void);
void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgCnt);
void __osDevMgrMain(void* arg);
s32 __osPiRawStartDma(s32 dir, uintptr_t cartAddr, void* dramAddr, size_t size);
uintptr_t osVirtualToPhysical(void* vaddr);
void osViBlack(u8 active);
s32 __osSiRawReadIo(void* devAddr, u32* dst);
OSId osGetThreadId(OSThread* thread);
void osViSetMode(OSViMode* mode);
u32 __osProbeTLB(void*);
u32 osGetMemSize(void);
void osSetEventMesg(OSEvent e, OSMesgQueue* mq, OSMesg msg);
s32 _Printf(PrintCallback, void* arg, const char* fmt, va_list ap);
void osUnmapTLBAll(void);
s32 osEPiStartDma(OSPiHandle* handle, OSIoMesg* mb, s32 direction);
void osInvalICache(void* vaddr, s32 nbytes);
void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count);
void osInvalDCache(void* vaddr, s32 nbytes);
s32 osSendMesg(OSMesgQueue* mq, OSMesg msg, s32 flag);
s32 __osSiDeviceBusy(void);
s32 osJamMesg(OSMesgQueue* mq, OSMesg mesg, s32 flag);
void osSetThreadPri(OSThread* thread, OSPri pri);
OSPri osGetThreadPri(OSThread* thread);
s32 __osEPiRawReadIo(OSPiHandle* handle, uintptr_t devAddr, u32* data);
void osViSwapBuffer(void* vaddr);
s32 __osEPiRawStartDma(OSPiHandle* handle, s32 direction, uintptr_t cartAddr, void* dramAddr, size_t size);
u32 bcmp(void* __sl, void* __s2, u32 __n);
OSTime osGetTime(void);
void __osTimerServicesInit(void);
void __osTimerInterrupt(void);
void __osSetTimerIntr(OSTime time);
OSTime __osInsertTimer(OSTimer* timer);
u32 osGetCount(void);
void __osSetGlobalIntMask(OSHWIntr mask);
void __osSetCompare(u32);
void __osResetGlobalIntMask(OSHWIntr mask);
s32 __osDisableInt(void);
void __osRestoreInt(s32);
void __osViInit(void);
void __osViSwapContext(void);
OSMesgQueue* osPiGetCmdQueue(void);
s32 osEPiReadIo(OSPiHandle* handle, uintptr_t devAddr, u32* data);
void osViSetSpecialFeatures(u32 func);
OSPiHandle* osCartRomInit(void);
void __osSetFpcCsr(u32);
u32 __osGetFpcCsr();
s32 osEPiWriteIo(OSPiHandle* handle, uintptr_t devAddr, u32 data);
void osMapTLBRdb(void);
void osYieldThread(void);
u32 __osGetCause();
s32 __osEPiRawWriteIo(OSPiHandle* handle, uintptr_t devAddr, u32 data);
void _Litob(_Pft* args, u8 type);
void _Ldtob(_Pft* args, u8 type);
s32 __osSiRawWriteIo(void* devAddr, u32 val);
void osCreateViManager(OSPri pri);
OSViContext* __osViGetCurrentContext(void);
void osStartThread(OSThread* thread);
void osViSetYScale(f32 scale);
void osViSetXScale(f32 value);
void __osSetWatchLo(u32);
EnItem00* Item_DropCollectible(GlobalContext* globalCtx, Vec3f* spawnPos, s16 params);
EnItem00* Item_DropCollectible2(GlobalContext* globalCtx, Vec3f* spawnPos, s16 params);
void Item_DropCollectibleRandom(GlobalContext* globalCtx, Actor* fromActor, Vec3f* spawnPos, s16 params);
void FlagSet_Update(GlobalContext* globalCtx);
void Overlay_LoadGameState(GameStateOverlay* overlayEntry);
void Overlay_FreeGameState(GameStateOverlay* overlayEntry);
DamageTable* DamageTable_Get(s32 index);
void DamageTable_Clear(DamageTable* table);
void SaveContext_Init(void);
s32 func_800635D0(s32);
void func_800636C0(void);
void func_8006375C(s32 arg0, s32 arg1, const char* text);
void func_8006376C(u8 x, u8 y, u8 colorId, const char* text);
// ? func_80063828(?);
void func_8006390C(Input* input);
// ? func_80063C04(?);
void func_80063D7C(GraphicsContext* gfxCtx);
void* MemCopy(void* dest, void* src, s32 size);
void GetItem_Draw(GlobalContext* globalCtx, s16 drawId);
void func_8006BA00(GlobalContext* globalCtx);
void func_8006BA30(GlobalContext* globalCtx);
void Audio_PlaySoundAtPosition(GlobalContext* globalCtx, Vec3f* pos, s32 duration, u16 sfxId);
u16 ElfMessage_GetSariaText(GlobalContext* globalCtx);
u16 ElfMessage_GetCUpText(GlobalContext* globalCtx);
u16 Text_GetFaceReaction(GlobalContext* globalCtx, u32 reactionSet);
void Flags_UnsetAllEnv(GlobalContext* globalCtx);
void Flags_SetEnv(GlobalContext* globalCtx, s16 flag);
void Flags_UnsetEnv(GlobalContext* globalCtx, s16 flag);
s32 Flags_GetEnv(GlobalContext* globalCtx, s16 flag);
f32 func_8006C5A8(f32 target, TransformData* transData, s32 refIdx);
void SkelCurve_Clear(SkelAnimeCurve* skelCurve);
s32 SkelCurve_Init(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve, SkelCurveLimbList* limbListSeg,
TransformUpdateIndex* transUpdIdx);
void SkelCurve_Destroy(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve);
void SkelCurve_SetAnim(SkelAnimeCurve* skelCurve, TransformUpdateIndex* transUpdIdx, f32 arg2, f32 animFinalFrame,
f32 animCurFrame, f32 animSpeed);
s32 SkelCurve_Update(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve);
void SkelCurve_Draw(Actor* actor, GlobalContext* globalCtx, SkelAnimeCurve* skelCurve,
OverrideCurveLimbDraw overrideLimbDraw, PostCurveLimbDraw postLimbDraw, s32 lod, void* data);
s32 func_8006CFC0(s32 scene);
void func_8006D074(GlobalContext* globalCtx);
void func_8006D0AC(GlobalContext* globalCtx);
void func_8006D0EC(GlobalContext* globalCtx, Player* player);
void func_8006D684(GlobalContext* globalCtx, Player* player);
void func_8006DC68(GlobalContext* globalCtx, Player* player);
void func_8006DD9C(Actor* actor, Vec3f* arg1, s16 arg2);
s32 Jpeg_Decode(void* data, void* zbuffer, void* workBuff, u32 workSize);
void KaleidoSetup_Update(GlobalContext* globalCtx);
void KaleidoSetup_Init(GlobalContext* globalCtx);
void KaleidoSetup_Destroy(GlobalContext* globalCtx);
void func_8006EE50(Font* font, u16 arg1, u16 arg2);
void Font_LoadChar(Font* font, u8 character, u16 codePointIndex);
void Font_LoadMessageBoxIcon(Font* font, u16 icon);
void Font_LoadOrderedFont(Font* font);
void Lib_MemSet(u8* dest, size_t size, u8 val);
void func_80077D10(f32* arg0, s16* arg1, Input* input);
s16 Rand_S16Offset(s16 base, s16 range);
void Actor_ProcessInitChain(Actor* actor, InitChainEntry* initChain);
void Color_RGBA8_Copy(Color_RGBA8* dst, Color_RGBA8* src);
void Common_PlaySfx(u16 sfxId);
void Common_PlaySfx2(u16 sfxId);
void Common_PlaySfxAtPos(Vec3f* arg0, u16 sfxId);
void HealthMeter_Init(GlobalContext* globalCtx);
void HealthMeter_Update(GlobalContext* globalCtx);
void HealthMeter_Draw(GlobalContext* globalCtx);
void HealthMeter_UpdateBeatingHeart(GlobalContext* globalCtx);
u32 HealthMeter_IsCritical(void);
void ZeldaArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action);
void* ZeldaArena_Malloc(u32 size);
void* ZeldaArena_MallocDebug(u32 size, const char* file, s32 line);
void* ZeldaArena_MallocR(u32 size);
void* ZeldaArena_MallocRDebug(u32 size, const char* file, s32 line);
void* ZeldaArena_Realloc(void* ptr, u32 newSize);
void* ZeldaArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line);
void ZeldaArena_Free(void* ptr);
void ZeldaArena_FreeDebug(void* ptr, const char* file, s32 line);
void* ZeldaArena_Calloc(u32 num, u32 size);
void ZeldaArena_Display();
void ZeldaArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc);
void ZeldaArena_Check();
void ZeldaArena_Init(void* start, u32 size);
void ZeldaArena_Cleanup();
u8 ZeldaArena_IsInitalized();
void MapMark_Init(GlobalContext* globalCtx);
void MapMark_ClearPointers(GlobalContext* globalCtx);
void MapMark_Draw(GlobalContext* globalCtx);
void PreNmiBuff_Init(PreNmiBuff* thiss);
void PreNmiBuff_SetReset(PreNmiBuff* thiss);
u32 PreNmiBuff_IsResetting(PreNmiBuff* thiss);
void MsgEvent_SendNullTask(void);
f32 OLib_Vec3fDist(Vec3f* a, Vec3f* b);
f32 OLib_Vec3fDistXZ(Vec3f* a, Vec3f* b);
f32 OLib_ClampMinDist(f32 val, f32 min);
f32 OLib_ClampMaxDist(f32 val, f32 max);
Vec3f* OLib_Vec3fDistNormalize(Vec3f* dest, Vec3f* a, Vec3f* b);
Vec3f* OLib_VecSphGeoToVec3f(Vec3f* dest, VecSph* sph);
VecSph* OLib_Vec3fToVecSph(VecSph* dest, Vec3f* vec);
VecSph* OLib_Vec3fToVecSphGeo(VecSph* arg0, Vec3f* arg1);
VecSph* OLib_Vec3fDiffToVecSphGeo(VecSph* arg0, Vec3f* a, Vec3f* b);
Vec3f* OLib_Vec3fDiffRad(Vec3f* dest, Vec3f* a, Vec3f* b);
Path* Path_GetByIndex(GlobalContext* globalCtx, s16 index, s16 max);
f32 Path_OrientAndGetDistSq(Actor* actor, Path* path, s16 waypoint, s16* yaw);
void Path_CopyLastPoint(Path* path, Vec3f* dest);
void func_80095AA0(GlobalContext* globalCtx, Room* room, Input* arg2, UNK_TYPE arg3); // z_play
void func_8009638C(Gfx** displayList, void* source, void* tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 mode0,
u16 tlutCount, f32 frameX, f32 frameY);
void func_80096FD4(GlobalContext* globalCtx, Room* room);
s32 func_8009728C(GlobalContext* globalCtx, RoomContext* roomCtx, s32 roomNum);
s32 func_800973FC(GlobalContext* globalCtx, RoomContext* roomCtx);
void Room_Draw(GlobalContext* globalCtx, Room* room, u32 flags);
void func_80097534(GlobalContext* globalCtx, RoomContext* roomCtx);
void Sample_Destroy(GameState* thissx);
void Sample_Init(GameState* thissx);
void Inventory_ChangeEquipment(s16 equipment, u16 value);
u8 Inventory_DeleteEquipment(GlobalContext* globalCtx, s16 equipment);
void Inventory_ChangeUpgrade(s16 upgrade, s16 value);
void Object_InitBank(GlobalContext* globalCtx, ObjectContext* objectCtx);
void Object_UpdateBank(ObjectContext* objectCtx);
s32 Object_GetIndex(ObjectContext* objectCtx, s16 objectId);
s32 Object_IsLoaded(ObjectContext* objectCtx, s32 bankIndex);
void func_800981B8(ObjectContext* objectCtx);
s32 Scene_ExecuteCommands(GlobalContext* globalCtx, SceneCmd* sceneCmd);
void TransitionActor_InitContext(GameState* state, TransitionActorContext* transiActorCtx);
void func_800994A0(GlobalContext* globalCtx);
void Scene_Draw(GlobalContext* globalCtx);
void func_800A57C0(MtxF* mtx, Struct_800A57C0* arg1, Struct_800A598C* arg2, Vtx* arg3, Vec3f* arg4);
void func_800A598C(GraphicsContext* gfxCtx, PSkinAwb* skin, s32 limbIndex, s32 arg3);
void func_800A5E28(GraphicsContext* gfxCtx, PSkinAwb* skin, s32 limbIndex, s32 arg3, s32 arg4);
void func_800A5F60(GraphicsContext* gfxCtx, PSkinAwb* skin, s32 limbIndex, Gfx* arg3, s32 arg4);
void func_800A60D8(Actor* actor, GlobalContext* globalCtx, PSkinAwb* skin, SkinCallback callback, SkinCallback2 arg4,
s32 arg5, s32 arg6, s32 arg7);
void func_800A6330(Actor* actor, GlobalContext* globalCtx, PSkinAwb* skin, SkinCallback callback, s32 arg4);
void func_800A6360(Actor* thiss, GlobalContext* globalCtx, PSkinAwb* skin, SkinCallback callback, SkinCallback2 arg4,
s32 arg5);
void func_800A63CC(Actor* actor, GlobalContext* globalCtx, PSkinAwb* skin, SkinCallback callback, SkinCallback2 arg4,
s32 arg5, s32 arg6, s32 arg7);
void func_800A6408(PSkinAwb* skin, s32 joint, Vec3f* arg2, Vec3f* arg3);
void func_800A6460(GlobalContext* globalCtx, PSkinAwb* skin, s32 arg2);
void func_800A663C(GlobalContext* globalCtx, PSkinAwb* skin, SkeletonHeader* skeletonHeader,
AnimationHeader* animationHeader);
void func_800A6888(GlobalContext* globalCtx, PSkinAwb* skin);
s32 func_800A698C(PSkinAwb* skin, SkinLimb** limbs, MtxF* arg2, u8 arg3, u8 arg4);
s32 func_800A6AC4(PSkinAwb* skin, MtxF* arg1, Actor* actor, s32 arg3);
void func_800A7EC0(MtxF* mf, s16 a, f32 x, f32 y, f32 z);
void Sram_InitNewSave(void);
void Sram_InitDebugSave(void);
void Sram_OpenSave(SramContext* sramCtx);
void Sram_WriteSave(SramContext* sramCtx);
void Sram_VerifyAndLoadAllSaves(FileChooseContext* fileChoose, SramContext* sramCtx);
void Sram_InitSave(FileChooseContext* fileChoose, SramContext* sramCtx);
void Sram_EraseSave(FileChooseContext* fileChoose, SramContext* sramCtx);
void Sram_CopySave(FileChooseContext* fileChoose, SramContext* sramCtx);
void Sram_WriteSramHeader(SramContext* sramCtx);
void Sram_InitSram(GameState* gameState, SramContext* sramCtx);
void Sram_Alloc(GameState* gameState, SramContext* sramCtx);
void Sram_Init(GlobalContext* globalCtx, SramContext* sramCtx);
void SsSram_Init(uintptr_t addr, u8 handleType, u8 handleDomain, u8 handleLatency, u8 handlePageSize,
u8 handleRelDuration,
u8 handlePulse, u32 handleSpeed);
void SsSram_Dma(void* dramAddr, size_t size, s32 direction);
void SsSram_ReadWrite(uintptr_t addr, void* dramAddr, size_t size, s32 direction);
void Rumble_Init(PadMgr*, s32);
void Rumble_Shake2(f32, u8, u8, u8);
void Rumble_Shake(f32, u8, u8, u8);
void Rumble_Reset();
void Rumble_Destroy(void);
u32 Rumble_IsEnabled();
void Rumble_Stop();
void Rumble_Clear();
void Rumble_Enable(u32);
void ViMode_LogPrint(OSViMode* viMode);
void ViMode_Configure(ViMode* viMode, s32 mode, s32 type, s32 unk_70, s32 unk_74, s32 unk_78, s32 unk_7C, s32 width,
s32 height, s32 unk_left, s32 unk_right, s32 unk_top, s32 unk_bottom);
void ViMode_Save(ViMode* viMode);
void ViMode_Load(ViMode* viMode);
void ViMode_Init(ViMode* viMode);
void ViMode_Destroy(ViMode* viMode);
void ViMode_ConfigureFeatures(ViMode* viMode, s32 viFeatures);*/
void ViMode_Update(ViMode* viMode, Input* input);
/*void func_800ACE70(struct_801664F0* thiss);
void func_800ACE90(struct_801664F0* thiss);
void func_800ACE98(struct_801664F0* thiss, Gfx** gfxp);
void VisMono_Init(VisMono* thiss);
void VisMono_Destroy(VisMono* thiss);
void VisMono_DesaturateTLUT(VisMono* thiss, u16* tex);
Gfx* VisMono_DesaturateDList(VisMono* thiss, Gfx* gfx);
void VisMono_Draw(VisMono* thiss, Gfx** gfxp);
void VisMono_DrawOld(VisMono* thiss);
void func_800AD920(struct_80166500* thiss);
void func_800AD950(struct_80166500* thiss);
void func_800AD958(struct_80166500* thiss, Gfx** gfxp);
void Skybox_Init(GameState* state, SkyboxContext* skyboxCtx, s16 skyboxId);
Mtx* SkyboxDraw_UpdateMatrix(SkyboxContext* skyboxCtx, f32 x, f32 y, f32 z);
void SkyboxDraw_Draw(SkyboxContext* skyboxCtx, GraphicsContext* gfxCtx, s16 skyboxId, s16 blend, f32 x, f32 y, f32 z);
void SkyboxDraw_Update(SkyboxContext* skyboxCtx);
void PlayerCall_InitFuncPtrs(void);
void TransitionUnk_InitGraphics(TransitionUnk* thiss);
void TransitionUnk_InitData(TransitionUnk* thiss);
void TransitionUnk_Destroy(TransitionUnk* thiss);
TransitionUnk* TransitionUnk_Init(TransitionUnk* thiss, s32 row, s32 col);
void TransitionUnk_SetData(TransitionUnk* thiss);
void TransitionUnk_Draw(TransitionUnk* thiss, Gfx**);
void func_800B23E8(TransitionUnk* thiss);
// ? DbCamera_AddVecSph(?);
// ? DbCamera_CalcUpFromPitchYawRoll(?);
// ? DbCamera_SetTextValue(?);
// ? DbCamera_Vec3SToF(?);
// ? DbCamera_Vec3FToS(?);
// ? DbCamera_CopyVec3f(?);
// ? DbCamera_Vec3SToF2(?);
// ? func_800B3F94(?);
// ? func_800B3FF4(?);
// ? func_800B404C(?);
// ? func_800B4088(?);
// ? func_800B41DC(?);
// ? func_800B42C0(?);
// ? func_800B4370(?);
// ? func_800B44E0(?);
// ? DbCamera_PrintPoints(?);
// ? DbCamera_PrintF32Bytes(?);
// ? DbCamera_PrintU16Bytes(?);
// ? DbCamera_PrintS16Bytes(?);
// ? DbCamera_PrintCutBytes(?);
void DbCamera_Init(DbCamera* dbCamera, Camera* cameraPtr);
void DbgCamera_Enable(DbCamera* dbCamera, Camera* cam);
void DbCamera_Update(DbCamera* dbCamera, Camera* cam);
// ? DbCamera_GetFirstAvailableLetter(?);
// ? DbCamera_InitCut(?);
// ? DbCamera_ResetCut(?);
// ? DbCamera_CalcMempakAllocSize(?);
// ? DbCamera_GetMempakAllocSize(?);
// ? DbCamera_DrawSlotLetters(?);
// ? DbCamera_PrintAllCuts(?);
// ? func_800B91B0(?);
void DbCamera_Reset(Camera* cam, DbCamera* dbCam);
// ? DbCamera_UpdateDemoControl(?);
void func_800BB0A0(f32 u, Vec3f* pos, f32* roll, f32* viewAngle, f32* point0, f32* point1, f32* point2, f32* point3);
s32 func_800BB2B4(Vec3f* pos, f32* roll, f32* fov, CutsceneCameraPoint* point, s16* keyframe, f32* curFrame);
s32 Mempak_Init(s32 controllerNb);
s32 Mempak_GetFreeBytes(s32 controllerNb);
s32 Mempak_FindFile(s32 controllerNb, char start, char end);
s32 Mempak_Write(s32 controllerNb, char idx, void* buffer, s32 offset, s32 size);
s32 Mempak_Read(s32 controllerNb, char idx, void* buffer, s32 offset, s32 size);
s32 Mempak_Alloc(s32 controllerNb, char* idx, s32 size);
s32 Mempak_DeleteFile(s32 controllerNb, char idx);
s32 Mempak_GetFileSize(s32 controllerNb, char idx);
void KaleidoManager_LoadOvl(KaleidoMgrOverlay* ovl);
void KaleidoManager_ClearOvl(KaleidoMgrOverlay* ovl);
void KaleidoManager_Init(GlobalContext* globalCtx);
void KaleidoManager_Destroy();
void* KaleidoManager_GetRamAddr(void* vram);
void KaleidoScopeCall_LoadPlayer();
void KaleidoScopeCall_Init(GlobalContext* globalCtx);
void KaleidoScopeCall_Destroy(GlobalContext* globalCtx);
void KaleidoScopeCall_Update(GlobalContext* globalCtx);
void KaleidoScopeCall_Draw(GlobalContext* globalCtx);
void func_800BC490(GlobalContext* globalCtx, s16 point);
s32 func_800BC56C(GlobalContext* globalCtx, s16 arg1);
void func_800BC590(GlobalContext* globalCtx);
void func_800BC5E0(GlobalContext* globalCtx, s32 arg1);
s32 func_800C0CB8(GlobalContext* globalCtx);
s32 FrameAdvance_IsEnabled(GlobalContext* globalCtx);
s32 func_800C0D34(GlobalContext* globalCtx, Actor* actor, s16* yaw);
s32 func_800C0DB4(GlobalContext* globalCtx, Vec3f* pos);
void PreRender_SetValuesSave(PreRender* thiss, u32 width, u32 height, void* fbuf, void* zbuf, void* cvg);
void PreRender_Init(PreRender* thiss);
void PreRender_SetValues(PreRender* thiss, u32 width, u32 height, void* fbuf, void* zbuf);
void PreRender_Destroy(PreRender* thiss);
void func_800C0F28(PreRender* thiss, Gfx** gfxp, void* buf, void* bufSave);
void func_800C1258(PreRender* thiss, Gfx** gfxp);
void func_800C170C(PreRender* thiss, Gfx** gfxp, void* fbuf, void* fbufSave, u32 r, u32 g, u32 b, u32 a);
void func_800C1AE8(PreRender* thiss, Gfx** gfxp, void* fbuf, void* fbufSave);
void func_800C1B24(PreRender* thiss, Gfx** gfxp, void* fbuf, void* cvgSave);
void func_800C1E9C(PreRender* thiss, Gfx** gfxp);
void func_800C1F20(PreRender* thiss, Gfx** gfxp);
void func_800C1FA4(PreRender* thiss, Gfx** gfxp);
void func_800C20B4(PreRender* thiss, Gfx** gfxp);
void func_800C2118(PreRender* thiss, Gfx** gfxp);
void func_800C213C(PreRender* thiss, Gfx** gfxp);
void func_800C24BC(PreRender* thiss, Gfx** gfxp);
void func_800C24E0(PreRender* thiss, Gfx** gfxp);
void func_800C2500(PreRender* thiss, s32 x, s32 y);
void func_800C2FE4(PreRender* thiss);
void PreRender_Calc(PreRender* thiss);
void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size);
void THGA_Dt(TwoHeadGfxArena* thga);
u32 THGA_IsCrash(TwoHeadGfxArena* thga);
void THGA_Init(TwoHeadGfxArena* thga);
s32 THGA_GetSize(TwoHeadGfxArena* thga);
Gfx* THGA_GetHead(TwoHeadGfxArena* thga);
void THGA_SetHead(TwoHeadGfxArena* thga, Gfx* start);
Gfx* THGA_GetTail(TwoHeadGfxArena* thga);
Gfx* THGA_AllocStartArray8(TwoHeadGfxArena* thga, u32 count);
Gfx* THGA_AllocStart8(TwoHeadGfxArena* thga);
Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga);
Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size);
Gfx* THGA_AllocEndArray64(TwoHeadGfxArena* thga, u32 count);
Gfx* THGA_AllocEnd64(TwoHeadGfxArena* thga);
Gfx* THGA_AllocEndArray16(TwoHeadGfxArena* thga, u32 count);
Gfx* THGA_AllocEnd16(TwoHeadGfxArena* thga);
void Audio_StopAllBanks(void);
void func_800C3C80(AudioMgr* audioMgr);
void AudioMgr_HandleRetrace(AudioMgr* audioMgr);
void AudioMgr_HandlePRENMI(AudioMgr* audioMgr);
void AudioMgr_ThreadEntry(void* arg0);
void AudioMgr_Unlock(AudioMgr* audioMgr);
void AudioMgr_Init(AudioMgr* audioMgr, void* stack, OSPri pri, OSId id, SchedContext* sched, IrqMgr* irqMgr);
void TitleSetup_InitImpl(GameState* gameState);
void TitleSetup_Destroy(GameState* gameState);
void TitleSetup_Init(GameState* gameState);
ListAlloc* ListAlloc_Init(ListAlloc* thiss);
void* ListAlloc_Alloc(ListAlloc* thiss, u32 size);
void ListAlloc_Free(ListAlloc* thiss, void* data);
void ListAlloc_FreeAll(ListAlloc* thiss);
void Main_LogSystemHeap(void);
void Main(void* arg);
OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padmgr);
void PadMgr_UnlockSerialMesgQueue(PadMgr* padmgr, OSMesgQueue* ctrlrqueue);
void PadMgr_LockPadData(PadMgr* padmgr);
void PadMgr_UnlockPadData(PadMgr* padmgr);
void PadMgr_RumbleControl(PadMgr* padmgr);
void PadMgr_RumbleStop(PadMgr* padmgr);
void PadMgr_RumbleReset(PadMgr* padmgr);
void PadMgr_RumbleSet(PadMgr* padmgr, u8* ctrlrRumbles);
void PadMgr_ProcessInputs(PadMgr* padmgr);
void PadMgr_HandleRetraceMsg(PadMgr* padmgr);
void PadMgr_HandlePreNMI(PadMgr* padmgr);
// This function must remain commented out, because it is called incorrectly in
// fault.c (actual bug in game), and the compiler notices and won't compile it
// void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode);
void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* siIntMsgQ, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack);
void Sched_SwapFrameBuffer(CfbInfo* cfbInfo);
void func_800C84E4(SchedContext* sc, CfbInfo* cfbInfo);
void Sched_HandleReset(SchedContext* sc);
void Sched_HandleStart(SchedContext* sc);
void Sched_QueueTask(SchedContext* sc, OSScTask* task);
void Sched_Yield(SchedContext* sc);
OSScTask* func_800C89D4(SchedContext* sc, OSScTask* task);
s32 Sched_Schedule(SchedContext* sc, OSScTask** sp, OSScTask** dp, s32 state);
void func_800C8BC4(SchedContext* sc, OSScTask* task);
u32 Sched_IsComplete(SchedContext* sc, OSScTask* task);
void Sched_RunTask(SchedContext* sc, OSScTask* spTask, OSScTask* dpTask);
void Sched_HandleEntry(SchedContext* sc);
void Sched_HandleRetrace(SchedContext* sc);
void Sched_HandleRSPDone(SchedContext* sc);
void Sched_HandleRDPDone(SchedContext* sc);
void Sched_SendEntryMsg(SchedContext* sc);
void Sched_ThreadEntry(void* arg);
void Sched_Init(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, IrqMgr* irqMgr);
void SpeedMeter_InitImpl(SpeedMeter* thiss, u32 arg1, u32 y);
void SpeedMeter_Init(SpeedMeter* thiss);
void SpeedMeter_Destroy(SpeedMeter* thiss);
void SpeedMeter_DrawTimeEntries(SpeedMeter* thiss, GraphicsContext* gfxCtx);
void SpeedMeter_InitAllocEntry(SpeedMeterAllocEntry* entry, u32 maxval, u32 val, u16 backColor, u16 foreColor, u32 ulx,
u32 lrx, u32 uly, u32 lry);
void SpeedMeter_DrawAllocEntry(SpeedMeterAllocEntry* thiss, GraphicsContext* gfxCtx);
void SpeedMeter_DrawAllocEntries(SpeedMeter* meter, GraphicsContext* gfxCtx, GameState* state);
void Matrix_ScaleTrans(Mtx* mtx, f32 scaleX, f32 scaleY, f32 scaleZ, f32 posX, f32 posY, f32 posZ) ;
u64* SysUcode_GetUCodeBoot(void);
u64 SysUcode_GetUCodeBootSize(void);
u64* SysUcode_GetUCode(void);
u64* SysUcode_GetUCodeData(void);
void Rumble_Update(RumbleStruct* arg0);
void func_800D3140(RumbleStruct* arg0);
void func_800D3178(RumbleStruct* arg0);
void func_800D31A0(void);
void func_800D31F0(void);
void func_800D3210(void);
void IrqMgr_AddClient(IrqMgr* thiss, IrqMgrClient* c, OSMesgQueue* msgQ);
void IrqMgr_RemoveClient(IrqMgr* thiss, IrqMgrClient* c);
void IrqMgr_SendMesgForClient(IrqMgr* thiss, OSMesg msg);
void IrqMgr_JamMesgForClient(IrqMgr* thiss, OSMesg msg);
void IrqMgr_HandlePreNMI(IrqMgr* thiss);
void IrqMgr_CheckStack();
void IrqMgr_HandlePRENMI450(IrqMgr* thiss);
void IrqMgr_HandlePRENMI480(IrqMgr* thiss);
void IrqMgr_HandlePRENMI500(IrqMgr* thiss);
void IrqMgr_HandleRetrace(IrqMgr* thiss);
void IrqMgr_ThreadEntry(void* arg0);
void IrqMgr_Init(IrqMgr* thiss, void* stack, OSPri pri, u8 retraceCount);
void DebugArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action);
void* DebugArena_Malloc(u32 size);
void* DebugArena_MallocDebug(u32 size, const char* file, s32 line);
void* DebugArena_MallocR(u32 size);
void* DebugArena_MallocRDebug(u32 size, const char* file, s32 line);
void* DebugArena_Realloc(void* ptr, u32 newSize);
void* DebugArena_ReallocDebug(void* ptr, u32 newSize, const char* file, s32 line);
void DebugArena_Free(void* ptr);
void DebugArena_FreeDebug(void* ptr, const char* file, s32 line);
void* DebugArena_Calloc(u32 num, u32 size);
void DebugArena_Display(void);
void DebugArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc);
void DebugArena_Check(void);
void DebugArena_Init(void* start, u32 size);
void DebugArena_Cleanup(void);
u8 DebugArena_IsInitalized(void);
void Fault_SleepImpl(u32);
void Fault_ClientProcessThread(void* arg);
void Fault_ProcessClientContext(FaultClientContext*);
u32 Fault_ProcessClient(u32, u32, u32);
void Fault_AddClient(FaultClient*, void*, void*, void*);
void Fault_RemoveClient(FaultClient*);
void Fault_AddAddrConvClient(FaultAddrConvClient*, void*, void*);
void Fault_RemoveAddrConvClient(FaultAddrConvClient*);
u32 Fault_ConvertAddress(FaultAddrConvClient*);
void Fault_Sleep(u32);
void Fault_PadCallback(Input*);
void Fault_UpdatePadImpl();
u32 Fault_WaitForInputImpl();
void Fault_WaitForInput();
void Fault_DrawRec(s32, s32, s32, s32, u16);
void Fault_FillScreenBlack();
void Fault_FillScreenRed();
void Fault_DrawCornerRec(u16);
void Fault_PrintFReg(s32, f32*);
void Fault_LogFReg(s32, f32*);
void Fault_PrintFPCR(u32);
void Fault_LogFPCR(u32);
void Fault_PrintThreadContext(OSThread*);
void Fault_LogThreadContext(OSThread*);
OSThread* Fault_FindFaultedThread();
void Fault_Wait5Seconds();
void Fault_WaitForButtonCombo();
void Fault_DrawMemDumpPage(const char*, u32*, u32);
void Fault_DrawMemDump(u32, u32, u32, u32);
void Fault_WalkStack(u32* spPtr, u32* pcPtr, u32* raPtr);
void Fault_DrawStackTrace(OSThread* thread, s32 x, s32 y, s32 height);
void Fault_LogStackTrace(OSThread* thread, s32 height);
void Fault_ResumeThread(OSThread*);
void Fault_CommitFB();
void Fault_ProcessClients();
void Fault_UpdatePad();
void Fault_ThreadEntry(void*);
void Fault_SetFB(void*, u16, u16);
void Fault_Init(void);
void Fault_HangupFaultClient(const char*, const char*);
void Fault_AddHungupAndCrashImpl(const char*, const char*);
void Fault_AddHungupAndCrash(const char*, u32);
void FaultDrawer_SetOsSyncPrintfEnabled(u32);
void FaultDrawer_DrawRecImpl(s32, s32, s32, s32, u16);
void FaultDrawer_DrawChar(char);
s32 FaultDrawer_ColorToPrintColor(u16);
void FaultDrawer_UpdatePrintColor();
void FaultDrawer_SetForeColor(u16);
void FaultDrawer_SetBackColor(u16);
void FaultDrawer_SetFontColor(u16);
void FaultDrawer_SetCharPad(s8, s8);
void FaultDrawer_SetCursor(s32, s32);
void FaultDrawer_FillScreen();
void* FaultDrawer_FormatStringFunc(void*, const char*, u32);
void FaultDrawer_VPrintf(const char*, char*);
void FaultDrawer_Printf(const char*, ...);
void FaultDrawer_DrawText(s32, s32, const char*, ...);
void FaultDrawer_SetDrawerFB(void*, u16, u16);
void FaultDrawer_SetInputCallback(void (*)());
void FaultDrawer_SetDefault();
void GfxPrint_SetColor(GfxPrint* thiss, u32 r, u32 g, u32 b, u32 a);
void GfxPrint_SetPosPx(GfxPrint* thiss, s32 x, s32 y);
void GfxPrint_SetPos(GfxPrint* thiss, s32 x, s32 y);
void GfxPrint_SetBasePosPx(GfxPrint* thiss, s32 x, s32 y);
void GfxPrint_Init(GfxPrint* thiss);
void GfxPrint_Destroy(GfxPrint* thiss);
void GfxPrint_Open(GfxPrint* thiss, Gfx* dList);
Gfx* GfxPrint_Close(GfxPrint* thiss);
s32 GfxPrint_Printf(GfxPrint* thiss, const char* fmt, ...);
void func_800FBCE0();
void func_800FBFD8(void);
void* Overlay_AllocateAndLoad(void* vRomStart, void* vRomEnd, void* vRamStart, void* vRamEnd);
void MtxConv_F2L(Mtx* m1, MtxF* m2);
void MtxConv_L2F(MtxF* m1, Mtx* m2);
void Overlay_Relocate(void* allocatedVRamAddress, OverlayRelocationSection* overlayInfo, void* vRamAddress);
s32 Overlay_Load(void* vRomStart, void* vRomEnd, void* vRamStart, void* vRamEnd, void* allocatedVRamAddress);
// ? func_800FC800(?);
// ? func_800FC83C(?);
// ? func_800FCAB4(?);
void SystemHeap_Init(void* start, u32 size);
void PadUtils_Init(Input* input);
void func_800FCB70(void);
void PadUtils_ResetPressRel(Input* input);
u32 PadUtils_CheckCurExact(Input* input, u16 value);
u32 PadUtils_CheckCur(Input* input, u16 key);
u32 PadUtils_CheckPressed(Input* input, u16 key);
u32 PadUtils_CheckReleased(Input* input, u16 key);
u16 PadUtils_GetCurButton(Input* input);
u16 PadUtils_GetPressButton(Input* input);
s8 PadUtils_GetCurX(Input* input);
s8 PadUtils_GetCurY(Input* input);
void PadUtils_SetRelXY(Input* input, s32 x, s32 y);
s8 PadUtils_GetRelXImpl(Input* input);
s8 PadUtils_GetRelYImpl(Input* input);
s8 PadUtils_GetRelX(Input* input);
s8 PadUtils_GetRelY(Input* input);
void PadUtils_UpdateRelXY(Input* input);
s32 PadSetup_Init(OSMesgQueue* mq, u8* outMask, OSContStatus* status);
f32 ceilf(f32 x);
f32 truncf(f32 x);
f32 roundf(f32 x);
f32 nearbyintf(f32 x);
u32 Rand_Next(void);
void Rand_Seed(u32 seed);
f32 Rand_ZeroOne(void);
f32 Rand_Centered(void);
u32 Rand_Next_Variable(u32* rndNum);
f32 Rand_ZeroOne_Variable(u32* rndNum);
f32 Rand_Centered_Variable(u32* rndNum);
#ifndef USE_NATIVE_MALLOC
u32 ArenaImpl_GetFillAllocBlock(Arena* arena);
u32 ArenaImpl_GetFillFreeBlock(Arena* arena);
u32 ArenaImpl_GetCheckFreeBlock(Arena* arena);
void ArenaImpl_SetFillAllocBlock(Arena* arena);
void ArenaImpl_SetFillFreeBlock(Arena* arena);
void ArenaImpl_SetCheckFreeBlock(Arena* arena);
void ArenaImpl_UnsetFillAllocBlock(Arena* arena);
void ArenaImpl_UnsetFillFreeBlock(Arena* arena);
void ArenaImpl_UnsetCheckFreeBlock(Arena* arena);
void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena* arena);
void ArenaImpl_LockInit(Arena* arena);
void ArenaImpl_Lock(Arena* arena);
void ArenaImpl_Unlock(Arena* arena);
ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node);
ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node);
ArenaNode* ArenaImpl_GetLastBlock(Arena* arena);
void __osMallocInit(Arena* arena, void* start, u32 size);
void __osMallocAddBlock(Arena* arena, void* start, s32 size);
void ArenaImpl_RemoveAllBlocks(Arena* arena);
void __osMallocCleanup(Arena* arena);
u8 __osMallocIsInitalized(Arena* arena);
void __osMalloc_FreeBlockTest(Arena* arena, ArenaNode* node);
void* __osMalloc_NoLockDebug(Arena* arena, u32 size, const char* file, s32 line);
void* __osMallocDebug(Arena* arena, u32 size, const char* file, s32 line);
void* __osMallocRDebug(Arena* arena, u32 size, const char* file, s32 line);
void* __osMalloc_NoLock(Arena* arena, u32 size);
void* __osMalloc(Arena* arena, u32 size);
void* __osMallocR(Arena* arena, u32 size);
void __osFree_NoLock(Arena* arena, void* ptr);
void __osFree(Arena* arena, void* ptr);
void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, s32 line);
void __osFreeDebug(Arena* arena, void* ptr, const char* file, s32 line);
void* __osRealloc(Arena* arena, void* ptr, u32 newSize);
void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, s32 line);
void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc);
void __osDisplayArena(Arena* arena);
void ArenaImpl_FaultClient(Arena* arena);
u32 __osCheckArena(Arena* arena);
u8 func_800FF334(Arena* arena);
#endif
s32 PrintUtils_VPrintf(PrintCallback* pfn, const char* fmt, va_list args);
s32 PrintUtils_Printf(PrintCallback* pfn, const char* fmt, ...);
void Sleep_Cycles(OSTime cycles);
void Sleep_Nsec(u32 nsec);
void Sleep_Usec(u32 usec);
void Sleep_Msec(u32 ms);
void Sleep_Sec(u32 sec);
s32 osPfsFreeBlocks(OSPfs* pfs, s32* leftoverBytes);
s16 sins(u16);
OSTask* _VirtualToPhysicalTask(OSTask* intp);
void osSpTaskLoad(OSTask* task);
void osSpTaskStartGo(OSTask* task);
void __osSiCreateAccessQueue(void);
void __osSiGetAccess(void);
void __osSiRelAccess(void);
s32 osContInit(OSMesgQueue* mq, u8* ctl_present_bitfield, OSContStatus* status);
void __osContGetInitData(u8* ctl_present_bitfield, OSContStatus* status);
void __osPackRequestData(u8 poll);
s32 osContStartReadData(OSMesgQueue* mq);
void osContGetReadData(OSContPad* pad);
void __osPackReadData(void);
s32 __osSpRawStartDma(s32 direction, void* devAddr, void* dramAddr, u32 size);
s32 __osSiRawStartDma(s32 dir, void* addr);
void osSpTaskYield(void);
s32 __osPfsGetNextPage(OSPfs* pfs, u8* bank, __OSInode* inode, __OSInodeUnit* page);
s32 osPfsReadWriteFile(OSPfs* pfs, s32 fileNo, u8 flag, s32 offset, s32 size, u8* data);
s32 __osPfsGetStatus(OSMesgQueue* queue, s32 channel);
void __osPfsRequestOneChannel(s32 channel, u8 poll);
void __osPfsGetOneChannelData(s32 channel, OSContStatus* contData);
s32 osPfsAllocateFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName, s32 length, s32* fileNo);
s32 __osPfsDeclearPage(OSPfs* pfs, __OSInode* inode, s32 fileSizeInPages, s32* startPage, u8 bank, s32* decleared,
s32* finalPage);
u16 __osSumcalc(u8* ptr, s32 length);
s32 __osIdCheckSum(u16* ptr, u16* csum, u16* icsum);
s32 __osRepairPackId(OSPfs* pfs, __OSPackId* badid, __OSPackId* newid);
s32 __osCheckPackId(OSPfs* pfs, __OSPackId* check);
s32 __osGetId(OSPfs* pfs);
s32 __osCheckId(OSPfs* pfs);
s32 __osPfsRWInode(OSPfs* pfs, __OSInode* inode, u8 flag, u8 bank);
s32 osPfsFindFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName, s32* fileNo);
s32 osAfterPreNMI(void);
s32 osContStartQuery(OSMesgQueue* mq);
void osContGetQuery(OSContStatus* data);
OSYieldResult osSpTaskYielded(OSTask* task);
u32 __osSpDeviceBusy(void);
s32 osAiSetFrequency(u32 frequency);
OSThread* __osGetActiveQueue(void);
u32 osDpGetStatus(void);
void osDpSetStatus(u32 status);
s32 osPfsDeleteFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName);
s32 __osPfsReleasePages(OSPfs* pfs, __OSInode* inode, u8 initialPage, u8 bank, __OSInodeUnit* finalPage);
f32 cosf(f32);
s16 coss(u16);
void osViSetEvent(OSMesgQueue* mq, OSMesg m, u32 retraceCount);
s32 osPfsIsPlug(OSMesgQueue* mq, u8* pattern);
void __osPfsRequestData(u8 poll);
void __osPfsGetInitData(u8* pattern, OSContStatus* contData);
void guS2DInitBg(uObjBg* bg);
s32 __osPfsSelectBank(OSPfs* pfs, u8 bank);
s32 osContSetCh(u8 ch);
s32 osPfsFileState(OSPfs* pfs, s32 fileNo, OSPfsState* state);
s32 osPfsInitPak(OSMesgQueue* mq, OSPfs* pfs, s32 channel);
s32 __osPfsCheckRamArea(OSPfs* pfs);
s32 osPfsChecker(OSPfs* pfs);
s32 func_80105788(OSPfs* pfs, __OSInodeCache* cache);
s32 func_80105A60(OSPfs* pfs, __OSInodeUnit fpage, __OSInodeCache* cache);
u32 osAiGetLength(void);
s32 __osContRamWrite(OSMesgQueue* mq, s32 channel, u16 address, u8* buffer, s32 force);
s32 __osContRamRead(OSMesgQueue* ctrlrqueue, s32 channel, u16 addr, u8* data);
u8 __osContAddressCrc(u16 addr);
u8 __osContDataCrc(u8* data);
s32 osSetTimer(OSTimer* timer, OSTime countdown, OSTime interval, OSMesgQueue* mq, OSMesg msg);
u32 __osSpGetStatus(void);
void __osSpSetStatus(u32 status);
void osWritebackDCacheAll(void);
OSThread* __osGetCurrFaultedThread(void);
// ? __d_to_ll(?);
// ? __f_to_ll(?);
// ? __d_to_ull(?);
// ? __f_to_ull(?);
// ? __ll_to_d(?);
// ? __ll_to_f(?);
// ? __ull_to_d(?);
// ? __ull_to_f(?);
u32* osViGetCurrentFramebuffer(void);
s32 __osSpSetPc(void* pc);
f32 absf(f32);
void* func_80106860(void* ptr, s32 val, size_t size);
void* func_801068B0(void* dst, void* src, size_t size);
void Message_UpdateOcarinaGame(GlobalContext* globalCtx);
u8 Message_ShouldAdvance(GlobalContext* globalCtx);
void Message_CloseTextbox(GlobalContext*);
void Message_StartTextbox(GlobalContext* globalCtx, u16 textId, Actor* actor);
void Message_ContinueTextbox(GlobalContext* globalCtx, u16 textId);
void func_8010BD58(GlobalContext* globalCtx, u16 arg1);
void func_8010BD88(GlobalContext* globalCtx, u16 arg1);
u8 Message_GetState(MessageContext* msgCtx);
void Message_Draw(GlobalContext* globalCtx);
void Message_Update(GlobalContext* globalCtx);
void Message_SetTables(void);
void GameOver_Init(GlobalContext* globalCtx);
void GameOver_FadeInLights(GlobalContext* globalCtx);
void GameOver_Update(GlobalContext* globalCtx);
void func_80110990(GlobalContext* globalCtx);
void func_801109B0(GlobalContext* globalCtx);
void Message_Init(GlobalContext* globalCtx);
void func_80112098(GlobalContext* globalCtx);
void Title_Init(GameState* thissx);
void Title_Destroy(GameState* thissx);
void Select_Init(GameState* thissx);
void Select_Destroy(GameState* thissx);
#ifdef __cplusplus
}
#endif
*/

143
include/gfx.h
View File

@ -1,90 +1,93 @@
#pragma once
#include "ultra64/types.h"
#include "ultra64/printf.h"
#include "color.h"
#include "ultra64/gbi.h"
#include "ultra64/message.h"
#include "ultra64/printf.h"
#include "ultra64/sched.h"
#include "color.h"
#include "ultra64/types.h"
#include "z64.h"
struct FrameBufferSwap {
/* 0x0000 */ u16* curBuffer;
/* 0x0004 */ u16* nextBuffer;
struct FrameBufferSwap
{
/* 0x0000 */ u16* curBuffer;
/* 0x0004 */ u16* nextBuffer;
};
struct TwoHeadArena {
/* 0x0000 */ u32 size;
/* 0x0004 */ void* bufp;
/* 0x0008 */ void* head;
/* 0x000C */ void* tail;
struct TwoHeadArena
{
/* 0x0000 */ u32 size;
/* 0x0004 */ void* bufp;
/* 0x0008 */ void* head;
/* 0x000C */ void* tail;
}; // size = 0x10
struct TwoHeadGfxArena {
/* 0x0000 */ u32 size;
/* 0x0004 */ Gfx* bufp;
/* 0x0008 */ Gfx* p;
/* 0x000C */ Gfx* d;
struct TwoHeadGfxArena
{
/* 0x0000 */ u32 size;
/* 0x0004 */ Gfx* bufp;
/* 0x0008 */ Gfx* p;
/* 0x000C */ Gfx* d;
}; // size = 0x10
struct GraphicsContext {
/* 0x0000 */ Gfx* polyOpaBuffer; // Pointer to "Zelda 0"
/* 0x0004 */ Gfx* polyXluBuffer; // Pointer to "Zelda 1"
/* 0x0008 */ char unk_008[0x08]; // Unused, could this be pointers to "Zelda 2" / "Zelda 3"
/* 0x0010 */ Gfx* overlayBuffer; // Pointer to "Zelda 4"
/* 0x0014 */ u32 unk_014;
/* 0x0018 */ char unk_018[0x20];
/* 0x0038 */ OSMesg msgBuff[0x08];
/* 0x0058 */ OSMesgQueue* schedMsgQ;
/* 0x005C */ OSMesgQueue queue;
/* 0x0074 */ char unk_074[0x04];
/* 0x0078 */ OSScTask task; // size of OSScTask might be wrong
/* 0x00D0 */ char unk_0D0[0xE0];
/* 0x01B0 */ Gfx* workBuffer;
/* 0x01B4 */ TwoHeadGfxArena work;
/* 0x01C4 */ char unk_01C4[0xC0];
/* 0x0284 */ struct OSViMode* viMode;
/* 0x0288 */ char unk_0288[0x20]; // Unused, could this be Zelda 2/3 ?
/* 0x02A8 */ TwoHeadGfxArena overlay; // "Zelda 4"
/* 0x02B8 */ TwoHeadGfxArena polyOpa; // "Zelda 0"
/* 0x02C8 */ TwoHeadGfxArena polyXlu; // "Zelda 1"
/* 0x02D8 */ u32 gfxPoolIdx;
/* 0x02DC */ u16* curFrameBuffer;
/* 0x02E0 */ char unk_2E0[0x04];
/* 0x02E4 */ u32 viFeatures;
/* 0x02E8 */ s32 fbIdx;
/* 0x02EC */ void (*callback)(struct GraphicsContext*, void*);
/* 0x02F0 */ void* callbackParam;
/* 0x02F4 */ f32 xScale;
/* 0x02F8 */ f32 yScale;
/* 0x02FC */ char unk_2FC[0x04];
struct GraphicsContext
{
/* 0x0000 */ Gfx* polyOpaBuffer; // Pointer to "Zelda 0"
/* 0x0004 */ Gfx* polyXluBuffer; // Pointer to "Zelda 1"
/* 0x0008 */ char unk_008[0x08]; // Unused, could this be pointers to "Zelda 2" / "Zelda 3"
/* 0x0010 */ Gfx* overlayBuffer; // Pointer to "Zelda 4"
/* 0x0014 */ u32 unk_014;
/* 0x0018 */ char unk_018[0x20];
/* 0x0038 */ OSMesg msgBuff[0x08];
/* 0x0058 */ OSMesgQueue* schedMsgQ;
/* 0x005C */ OSMesgQueue queue;
/* 0x0074 */ char unk_074[0x04];
/* 0x0078 */ OSScTask task; // size of OSScTask might be wrong
/* 0x00D0 */ char unk_0D0[0xE0];
/* 0x01B0 */ Gfx* workBuffer;
/* 0x01B4 */ TwoHeadGfxArena work;
/* 0x01C4 */ char unk_01C4[0xC0];
/* 0x0284 */ struct OSViMode* viMode;
/* 0x0288 */ char unk_0288[0x20]; // Unused, could this be Zelda 2/3 ?
/* 0x02A8 */ TwoHeadGfxArena overlay; // "Zelda 4"
/* 0x02B8 */ TwoHeadGfxArena polyOpa; // "Zelda 0"
/* 0x02C8 */ TwoHeadGfxArena polyXlu; // "Zelda 1"
/* 0x02D8 */ u32 gfxPoolIdx;
/* 0x02DC */ u16* curFrameBuffer;
/* 0x02E0 */ char unk_2E0[0x04];
/* 0x02E4 */ u32 viFeatures;
/* 0x02E8 */ s32 fbIdx;
/* 0x02EC */ void (*callback)(struct GraphicsContext*, void*);
/* 0x02F0 */ void* callbackParam;
/* 0x02F4 */ f32 xScale;
/* 0x02F8 */ f32 yScale;
/* 0x02FC */ char unk_2FC[0x04];
}; // size = 0x300
struct GfxPool {
/* 0x00000 */ u16 headMagic; // GFXPOOL_HEAD_MAGIC
/* 0x00008 */ Gfx polyOpaBuffer[0x17E0*2]; // TODO FIX HACK
/* 0x0BF08 */ Gfx polyXluBuffer[0x800*2]; // TODO FIX HACK
/* 0x0FF08 */ Gfx overlayBuffer[0x400*2]; // TODO FIX HACK
/* 0x11F08 */ Gfx workBuffer[0x80*2]; // TODO FIX HACK
/* 0x12408 */ u16 tailMagic; // GFXPOOL_TAIL_MAGIC
}; // size = 0x12410
struct GfxPool
{
/* 0x00000 */ u16 headMagic; // GFXPOOL_HEAD_MAGIC
/* 0x00008 */ Gfx polyOpaBuffer[0x17E0 * 2]; // TODO FIX HACK
/* 0x0BF08 */ Gfx polyXluBuffer[0x800 * 2]; // TODO FIX HACK
/* 0x0FF08 */ Gfx overlayBuffer[0x400 * 2]; // TODO FIX HACK
/* 0x11F08 */ Gfx workBuffer[0x80 * 2]; // TODO FIX HACK
/* 0x12408 */ u16 tailMagic; // GFXPOOL_TAIL_MAGIC
}; // size = 0x12410
struct GfxPrint {
/* 0x00 */ PrintCallback callback;
/* 0x04 */ Gfx* dList;
/* 0x08 */ u16 posX;
/* 0x0A */ u16 posY;
/* 0x0C */ u16 baseX;
/* 0x0E */ u16 baseY;
/* 0x0F */ u16 flags;
/* 0x10 */ Color_RGBA8 color;
/* 0x14 */ char unk_14[0x1C]; // unused
}; // size = 0x30
struct GfxPrint
{
/* 0x00 */ PrintCallback callback;
/* 0x04 */ Gfx* dList;
/* 0x08 */ u16 posX;
/* 0x0A */ u16 posY;
/* 0x0C */ u16 baseX;
/* 0x0E */ u16 baseY;
/* 0x0F */ u16 flags;
/* 0x10 */ Color_RGBA8 color;
/* 0x14 */ char unk_14[0x1C]; // unused
}; // size = 0x30
extern u16 gZBuffer[SCREEN_HEIGHT][SCREEN_WIDTH];
extern GfxPool gGfxPools[2];
extern u8 gGfxSPTaskStack[0x400];
extern u8 gGfxSPTaskYieldBuffer[OS_YIELD_DATA_SIZE];
extern u64 gGfxSPTaskOutputBuffer[0x3000];

3
include/gfx_align.h
View File

@ -1,5 +1,6 @@
#pragma once
extern "C" {
extern "C"
{
u64 gfx_width();
u64 gfx_height();
float gfx_ar();

4
include/gfxapi.h
View File

@ -9,7 +9,7 @@ extern "C"
bool gfx_start_frame();
void gfx_end_frame();
void gfx_fbe_sync(GraphicsContext* gfxCtx, GameInfo* GameInfo);
int gfx_fbe_is_enabled();
int gfx_fbe_is_enabled();
void gfx_fbe_enable(int enable);
void gfx_force_43(bool enable); // From GlideN64
bool gfx_force_43_enabled();
@ -18,5 +18,3 @@ extern "C"
void gfx_filter_sepia_enabled();
void gfx_filter_sepia_disable();
}

1
include/global.h
View File

@ -22,4 +22,3 @@ u64 osGetTime();
void oot_assert(const char* exp, const char* file, s32 line);
#include "z_debug_display.h"

2
include/hack.h
View File

@ -1,3 +1 @@
#pragma once

64
include/ichain.h
View File

@ -1,25 +1,27 @@
#ifndef ICHAIN_H
#define ICHAIN_H
struct InitChainEntry {
u32 cont: 1;
u32 type: 4;
u32 offset: 11;
s32 value: 16;
struct InitChainEntry
{
u32 cont : 1;
u32 type : 4;
u32 offset : 11;
s32 value : 16;
};
enum InitChainType {
/* 0x0 */ ICHAINTYPE_U8, // sets byte
/* 0x1 */ ICHAINTYPE_S8,
/* 0x2 */ ICHAINTYPE_U16, // sets short
/* 0x3 */ ICHAINTYPE_S16,
/* 0x4 */ ICHAINTYPE_U32, // sets word
/* 0x5 */ ICHAINTYPE_S32,
/* 0x6 */ ICHAINTYPE_F32, // sets float
/* 0x7 */ ICHAINTYPE_F32_DIV1000, // sets float divided by 1000
/* 0x8 */ ICHAINTYPE_VEC3F, // sets Vec3f members
/* 0x9 */ ICHAINTYPE_VEC3F_DIV1000, // sets Vec3f members divided by 1000
/* 0xA */ ICHAINTYPE_VEC3S // sets Vec3s members
enum InitChainType
{
/* 0x0 */ ICHAINTYPE_U8, // sets byte
/* 0x1 */ ICHAINTYPE_S8,
/* 0x2 */ ICHAINTYPE_U16, // sets short
/* 0x3 */ ICHAINTYPE_S16,
/* 0x4 */ ICHAINTYPE_U32, // sets word
/* 0x5 */ ICHAINTYPE_S32,
/* 0x6 */ ICHAINTYPE_F32, // sets float
/* 0x7 */ ICHAINTYPE_F32_DIV1000, // sets float divided by 1000
/* 0x8 */ ICHAINTYPE_VEC3F, // sets Vec3f members
/* 0x9 */ ICHAINTYPE_VEC3F_DIV1000, // sets Vec3f members divided by 1000
/* 0xA */ ICHAINTYPE_VEC3S // sets Vec3s members
};
/**
@ -35,22 +37,24 @@ enum InitChainType {
* * value ---- s16 value to use
* * cont ----- ICHAIN_CONTINUE (or ICHAIN_STOP) to continue (or stop) parsing
*/
#define ICHAIN(type, member, value, cont) \
{ cont, type, OFFSETOF(Actor, member), value }
#define ICHAIN(type, member, value, cont) \
{ \
cont, type, OFFSETOF(Actor, member), value \
}
#define ICHAIN_U8(member, val, cont) ICHAIN(ICHAINTYPE_U8, member, val, cont)
#define ICHAIN_S8(member, val, cont) ICHAIN(ICHAINTYPE_S8, member, val, cont)
#define ICHAIN_U16(member, val, cont) ICHAIN(ICHAINTYPE_U16, member, val, cont)
#define ICHAIN_S16(member, val, cont) ICHAIN(ICHAINTYPE_S16, member, val, cont)
#define ICHAIN_U32(member, val, cont) ICHAIN(ICHAINTYPE_U32, member, val, cont)
#define ICHAIN_S32(member, val, cont) ICHAIN(ICHAINTYPE_S32, member, val, cont)
#define ICHAIN_F32(member, val, cont) ICHAIN(ICHAINTYPE_F32, member, val, cont)
#define ICHAIN_F32_DIV1000(member, val, cont) ICHAIN(ICHAINTYPE_F32_DIV1000, member, val, cont)
#define ICHAIN_VEC3F(member, val, cont) ICHAIN(ICHAINTYPE_VEC3F, member, val, cont)
#define ICHAIN_U8(member, val, cont) ICHAIN(ICHAINTYPE_U8, member, val, cont)
#define ICHAIN_S8(member, val, cont) ICHAIN(ICHAINTYPE_S8, member, val, cont)
#define ICHAIN_U16(member, val, cont) ICHAIN(ICHAINTYPE_U16, member, val, cont)
#define ICHAIN_S16(member, val, cont) ICHAIN(ICHAINTYPE_S16, member, val, cont)
#define ICHAIN_U32(member, val, cont) ICHAIN(ICHAINTYPE_U32, member, val, cont)
#define ICHAIN_S32(member, val, cont) ICHAIN(ICHAINTYPE_S32, member, val, cont)
#define ICHAIN_F32(member, val, cont) ICHAIN(ICHAINTYPE_F32, member, val, cont)
#define ICHAIN_F32_DIV1000(member, val, cont) ICHAIN(ICHAINTYPE_F32_DIV1000, member, val, cont)
#define ICHAIN_VEC3F(member, val, cont) ICHAIN(ICHAINTYPE_VEC3F, member, val, cont)
#define ICHAIN_VEC3F_DIV1000(member, val, cont) ICHAIN(ICHAINTYPE_VEC3F_DIV1000, member, val, cont)
#define ICHAIN_VEC3S(member, val, cont) ICHAIN(ICHAINTYPE_VEC3S, member, val, cont)
#define ICHAIN_VEC3S(member, val, cont) ICHAIN(ICHAINTYPE_VEC3S, member, val, cont)
#define ICHAIN_CONTINUE 1
#define ICHAIN_STOP 0
#define ICHAIN_STOP 0
#endif

158
include/interface.h
View File

@ -3,82 +3,84 @@
#include "view.h"
#include "z64dma.h"
struct InterfaceContext {
/* 0x0000 */ View view;
/* 0x0128 */ Vtx* actionVtx;
/* 0x012C */ Vtx* beatingHeartVtx;
/* 0x0130 */ u8* parameterSegment;
/* 0x0134 */ u8* doActionSegment1;
u8* doActionSegment2;
u8* doActionSegment3;
/* 0x0138 */ u8* iconItemSegment1;
u8* iconItemSegment2;
u8* iconItemSegment3;
u8* iconItemSegment4;
/* 0x013C */ u8* mapSegment1;
u8* mapSegment2;
/* 0x0140 */ u8 mapPalette[32];
/* 0x0160 */ DmaRequest dmaRequest_160;
/* 0x0180 */ DmaRequest dmaRequest_180;
/* 0x01A0 */ char unk_1A0[0x20];
/* 0x01C0 */ OSMesgQueue loadQueue;
/* 0x01D8 */ OSMesg loadMsg;
/* 0x01DC */ Viewport viewport;
/* 0x01EC */ s16 unk_1EC;
/* 0x01EE */ u16 unk_1EE;
/* 0x01F0 */ u16 unk_1F0;
/* 0x01F4 */ f32 unk_1F4;
/* 0x01F8 */ s16 naviCalling;
/* 0x01FA */ s16 unk_1FA;
/* 0x01FC */ s16 unk_1FC;
/* 0x01FE */ s16 heartColorOscillator;
/* 0x0200 */ s16 heartColorOscillatorDirection;
/* 0x0202 */ s16 beatingHeartPrim[3];
/* 0x0208 */ s16 beatingHeartEnv[3];
/* 0x020E */ s16 heartsPrimR[2];
/* 0x0212 */ s16 heartsPrimG[2];
/* 0x0216 */ s16 heartsPrimB[2];
/* 0x021A */ s16 heartsEnvR[2];
/* 0x021E */ s16 heartsEnvG[2];
/* 0x0222 */ s16 heartsEnvB[2];
/* 0x022A */ Timer beatingHeartOscillator;
/* 0x022C */ s16 beatingHeartOscillatorDirection;
/* 0x022E */ s16 unk_22E;
/* 0x0230 */ s16 unk_230;
/* 0x0232 */ s16 counterDigits[4]; // used for key and rupee counters
/* 0x023A */ u8 numHorseBoosts;
/* 0x023C */ u16 unk_23C;
/* 0x023E */ u16 hbaAmmo; // ammo while playing the horseback archery minigame
/* 0x0240 */ u16 unk_240;
/* 0x0242 */ u16 unk_242;
/* 0x0224 */ u16 unk_244; // screen fill alpha?
/* 0x0246 */ u16 aAlpha; // also carrots alpha
/* 0x0248 */ u16 bAlpha; // also HBA score alpha
/* 0x024A */ u16 cLeftAlpha;
/* 0x024C */ u16 cDownAlpha;
/* 0x024E */ u16 cRightAlpha;
/* 0x0250 */ u16 healthAlpha; // also max C-Up alpha
/* 0x0252 */ u16 magicAlpha; // also Rupee and Key counters alpha
/* 0x0254 */ u16 minimapAlpha;
/* 0x0256 */ s16 startAlpha;
/* 0x0258 */ s16 unk_258;
/* 0x025A */ s16 unk_25A;
/* 0x025C */ s16 mapRoomNum;
/* 0x025E */ s16 mapPaletteIndex; // "map_palete_no"
/* 0x0260 */ u8 unk_260;
/* 0x0261 */ u8 unk_261;
struct {
/* 0x0262 */ u8 hGauge; // "h_gage"; unknown?
/* 0x0263 */ u8 bButton; // "b_button"
/* 0x0264 */ u8 aButton; // "a_button"
/* 0x0265 */ u8 bottles; // "c_bottle"
/* 0x0266 */ u8 tradeItems; // "c_warasibe"
/* 0x0267 */ u8 hookshot; // "c_hook"
/* 0x0268 */ u8 ocarina; // "c_ocarina"
/* 0x0269 */ u8 warpSongs; // "c_warp"
/* 0x026A */ u8 sunsSong; // "m_sunmoon"
/* 0x026B */ u8 farores; // "m_wind"
/* 0x026C */ u8 dinsNayrus; // "m_magic"; din's fire and nayru's love
/* 0x026D */ u8 all; // "another"; enables all item restrictions
} restrictions;
struct InterfaceContext
{
/* 0x0000 */ View view;
/* 0x0128 */ Vtx* actionVtx;
/* 0x012C */ Vtx* beatingHeartVtx;
/* 0x0130 */ u8* parameterSegment;
/* 0x0134 */ u8* doActionSegment1;
u8* doActionSegment2;
u8* doActionSegment3;
/* 0x0138 */ u8* iconItemSegment1;
u8* iconItemSegment2;
u8* iconItemSegment3;
u8* iconItemSegment4;
/* 0x013C */ u8* mapSegment1;
u8* mapSegment2;
/* 0x0140 */ u8 mapPalette[32];
/* 0x0160 */ DmaRequest dmaRequest_160;
/* 0x0180 */ DmaRequest dmaRequest_180;
/* 0x01A0 */ char unk_1A0[0x20];
/* 0x01C0 */ OSMesgQueue loadQueue;
/* 0x01D8 */ OSMesg loadMsg;
/* 0x01DC */ Viewport viewport;
/* 0x01EC */ s16 unk_1EC;
/* 0x01EE */ u16 unk_1EE;
/* 0x01F0 */ u16 unk_1F0;
/* 0x01F4 */ f32 unk_1F4;
/* 0x01F8 */ s16 naviCalling;
/* 0x01FA */ s16 unk_1FA;
/* 0x01FC */ s16 unk_1FC;
/* 0x01FE */ s16 heartColorOscillator;
/* 0x0200 */ s16 heartColorOscillatorDirection;
/* 0x0202 */ s16 beatingHeartPrim[3];
/* 0x0208 */ s16 beatingHeartEnv[3];
/* 0x020E */ s16 heartsPrimR[2];
/* 0x0212 */ s16 heartsPrimG[2];
/* 0x0216 */ s16 heartsPrimB[2];
/* 0x021A */ s16 heartsEnvR[2];
/* 0x021E */ s16 heartsEnvG[2];
/* 0x0222 */ s16 heartsEnvB[2];
/* 0x022A */ Timer beatingHeartOscillator;
/* 0x022C */ s16 beatingHeartOscillatorDirection;
/* 0x022E */ s16 unk_22E;
/* 0x0230 */ s16 unk_230;
/* 0x0232 */ s16 counterDigits[4]; // used for key and rupee counters
/* 0x023A */ u8 numHorseBoosts;
/* 0x023C */ u16 unk_23C;
/* 0x023E */ u16 hbaAmmo; // ammo while playing the horseback archery minigame
/* 0x0240 */ u16 unk_240;
/* 0x0242 */ u16 unk_242;
/* 0x0224 */ u16 unk_244; // screen fill alpha?
/* 0x0246 */ u16 aAlpha; // also carrots alpha
/* 0x0248 */ u16 bAlpha; // also HBA score alpha
/* 0x024A */ u16 cLeftAlpha;
/* 0x024C */ u16 cDownAlpha;
/* 0x024E */ u16 cRightAlpha;
/* 0x0250 */ u16 healthAlpha; // also max C-Up alpha
/* 0x0252 */ u16 magicAlpha; // also Rupee and Key counters alpha
/* 0x0254 */ u16 minimapAlpha;
/* 0x0256 */ s16 startAlpha;
/* 0x0258 */ s16 unk_258;
/* 0x025A */ s16 unk_25A;
/* 0x025C */ s16 mapRoomNum;
/* 0x025E */ s16 mapPaletteIndex; // "map_palete_no"
/* 0x0260 */ u8 unk_260;
/* 0x0261 */ u8 unk_261;
struct
{
/* 0x0262 */ u8 hGauge; // "h_gage"; unknown?
/* 0x0263 */ u8 bButton; // "b_button"
/* 0x0264 */ u8 aButton; // "a_button"
/* 0x0265 */ u8 bottles; // "c_bottle"
/* 0x0266 */ u8 tradeItems; // "c_warasibe"
/* 0x0267 */ u8 hookshot; // "c_hook"
/* 0x0268 */ u8 ocarina; // "c_ocarina"
/* 0x0269 */ u8 warpSongs; // "c_warp"
/* 0x026A */ u8 sunsSong; // "m_sunmoon"
/* 0x026B */ u8 farores; // "m_wind"
/* 0x026C */ u8 dinsNayrus; // "m_magic"; din's fire and nayru's love
/* 0x026D */ u8 all; // "another"; enables all item restrictions
} restrictions;
}; // size = 0x270

10
include/json.h
View File

@ -1,8 +1,9 @@
#pragma once
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/prettywriter.h"
#include <rapidjson/istreamwrapper.h>
#include "rapidjson/document.h"
#include "rapidjson/prettywriter.h"
#include "rapidjson/stringbuffer.h"
#include "ultra64/types.h"
namespace oot::json
{
@ -18,5 +19,4 @@ namespace oot::json
bool getU64(rapidjson::Value& document, const char* key, u64& value);
bool getBool(rapidjson::Value& document, const char* key, bool& value);
bool getFloat(rapidjson::Value& document, const char* key, float& value);
}
} // namespace oot::json

2
include/kaleido.h
View File

@ -1,7 +1,7 @@
#pragma once
#include "z64animation.h"
#include "ultra64/types.h"
#include "view.h"
#include "z64animation.h"
struct KaleidoMgrOverlay
{

21
include/libc.bak/math.h
View File

@ -10,18 +10,21 @@
#define SHT_MINV (1.0f / SHT_MAX)
#define DEGTORAD(x) (x * M_PI / 180.0f)
typedef union {
struct {
u32 hi;
u32 lo;
} word;
typedef union
{
struct
{
u32 hi;
u32 lo;
} word;
f64 d;
f64 d;
} du;
union fu {
u32 i;
f32 f;
union fu
{
u32 i;
f32 f;
};
extern f32 __libm_qnan_f;

24
include/libc.bak/stdarg.h
View File

@ -19,28 +19,20 @@ typedef char* va_list;
#define _VA_ALIGN(p, a) (((u32)(((char*)p) + ((a) > 4 ? (a) : 4) - 1)) & -((a) > 4 ? (a) : 4))
#define va_start(vp, parmN) (vp = ((va_list)&parmN + sizeof(parmN)))
#define __va_stack_arg(list, mode) \
( \
((list) = (char*)_VA_ALIGN(list, __builtin_alignof(mode)) + \
_VA_ALIGN(sizeof(mode), 4)), \
(((char*)list) - (_VA_ALIGN(sizeof(mode), 4) - sizeof(mode))))
#define __va_stack_arg(list, mode) (((list) = (char*)_VA_ALIGN(list, __builtin_alignof(mode)) + _VA_ALIGN(sizeof(mode), 4)), (((char*)list) - (_VA_ALIGN(sizeof(mode), 4) - sizeof(mode))))
#define __va_double_arg(list, mode) \
( \
(((s32)list & 0x1) /* 1 byte aligned? */ \
? (list = (char*)((s32)list + 7), (char*)((s32)list - 6 - _VA_FP_SAVE_AREA)) \
: (((s32)list & 0x2) /* 2 byte aligned? */ \
? (list = (char*)((s32)list + 10), (char*)((s32)list - 24 - _VA_FP_SAVE_AREA)) \
: __va_stack_arg(list, mode))))
#define __va_double_arg(list, mode) \
((((s32)list & 0x1) /* 1 byte aligned? */ \
? (list = (char*)((s32)list + 7), (char*)((s32)list - 6 - _VA_FP_SAVE_AREA)) \
: (((s32)list & 0x2) /* 2 byte aligned? */ \
? (list = (char*)((s32)list + 10), (char*)((s32)list - 24 - _VA_FP_SAVE_AREA)) \
: __va_stack_arg(list, mode))))
#ifdef _MSC_VER
// TODO FIX
#define va_arg(list, mode) (mode)0
#else
#define va_arg(list, mode) ((mode*)(((__builtin_classof(mode) == _FP && \
__builtin_alignof(mode) == sizeof(f64)) \
? __va_double_arg(list, mode) \
: __va_stack_arg(list, mode))))[-1]
#define va_arg(list, mode) ((mode*)(((__builtin_classof(mode) == _FP && __builtin_alignof(mode) == sizeof(f64)) ? __va_double_arg(list, mode) : __va_stack_arg(list, mode))))[-1]
#endif
#define va_end(__list)

6
include/libc.bak/stdbool.h
View File

@ -5,9 +5,9 @@
#ifndef __cplusplus
#define bool u32
#define false 0
#define true 1
#define bool u32
#define false 0
#define true 1
#endif /* __cplusplus */

14
include/libc.bak/stdlib.h
View File

@ -3,14 +3,16 @@
#include "ultra64.h"
struct lldiv_t {
s64 quot;
s64 rem;
struct lldiv_t
{
s64 quot;
s64 rem;
};
struct ldiv_t {
s32 quot;
s32 rem;
struct ldiv_t
{
s32 quot;
s32 rem;
};
#endif

8
include/listalloc.h
View File

@ -1,7 +1,7 @@
#pragma once
struct ListAlloc {
/* 0x00 */ struct ListAlloc* prev;
/* 0x04 */ struct ListAlloc* next;
struct ListAlloc
{
/* 0x00 */ struct ListAlloc* prev;
/* 0x04 */ struct ListAlloc* next;
}; // size = 0x8

134
include/macros.h
View File

@ -13,9 +13,9 @@
#define ALIGN64(val) (((val) + 0x3F) & ~0x3F)
#define ALIGN256(val) (((val) + 0xFF) & ~0xFF)
#define OFFSETOF(structure, member) ((size_t)&(((structure*)0)->member))
#define OFFSETOF(structure, member) ((size_t) & (((structure*)0)->member))
#define SQ(x) ((x)*(x))
#define SQ(x) ((x) * (x))
#define ABS(x) ((x) >= 0 ? (x) : -(x))
#define DECR(x) ((x).dec())
#define DECRI(x) ((x) == 0 ? 0 : --(x))
@ -23,27 +23,23 @@
#define CLAMP(x, min, max) ((x) < (min) ? (min) : (x) > (max) ? (max) : (x))
#define CLAMP_MAX(x, max) ((x) > (max) ? (max) : (x))
#define CLAMP_MIN(x, min) ((x) < (min) ? (min) : (x))
#define MEDIAN3(a1, a2, a3) \
(((a2) >= (a1)) ? (((a3) >= (a2)) ? (a2) : (((a1) >= (a3)) ? (a1) : (a3))) \
: (((a2) >= (a3)) ? (a2) : (((a3) >= (a1)) ? (a1) : (a3))))
#define MEDIAN3(a1, a2, a3) (((a2) >= (a1)) ? (((a3) >= (a2)) ? (a2) : (((a1) >= (a3)) ? (a1) : (a3))) : (((a2) >= (a3)) ? (a2) : (((a3) >= (a1)) ? (a1) : (a3))))
#ifdef LITTLE_ENDIAN
#define RGBA8(r, g, b, a) ((((a) & 0xFF) << 24) | (((b) & 0xFF) << 16) | (((g) & 0xFF) << 8) | (((r) & 0xFF) << 0))
#define RGBA8(r, g, b, a) ((((a)&0xFF) << 24) | (((b)&0xFF) << 16) | (((g)&0xFF) << 8) | (((r)&0xFF) << 0))
#else
#define RGBA8(r, g, b, a) ((((r) & 0xFF) << 24) | (((g) & 0xFF) << 16) | (((b) & 0xFF) << 8) | (((a) & 0xFF) << 0))
#define RGBA8(r, g, b, a) ((((r)&0xFF) << 24) | (((g)&0xFF) << 16) | (((b)&0xFF) << 8) | (((a)&0xFF) << 0))
#endif
#define GET_PLAYER(globalCtx) ((Player*)(globalCtx)->actorCtx.actorLists[ACTORCAT_PLAYER].head)
#define GET_ACTIVE_CAM(globalCtx) ((globalCtx)->cameraPtrs[(globalCtx)->activeCamera])
#define CHECK_BTN_ALL(state, combo) (~((state) | ~(combo)) == 0)
#define CHECK_BTN_ANY(state, combo) (((state) & (combo)) != 0)
#define CHECK_FLAG_ALL(flags, mask) (((flags) & (mask)) == (mask))
#define LOG(exp, value, format, file, line) 0
#define LOG_STRING(string, file, line) LOG(#string, string, "%s", file, line)
@ -53,42 +49,43 @@
#define LOG_HEX(exp, value, file, line) LOG(exp, value, "%x", file, line)
#define LOG_FLOAT(exp, value, file, line) LOG(exp, value, "%f", file, line)
#define SET_NEXT_GAMESTATE(curState, newInit, newStruct) \
do { \
(curState)->init = newInit; \
(curState)->size = sizeof(newStruct); \
} while (0)
#define SET_NEXT_GAMESTATE(curState, newInit, newStruct) \
do \
{ \
(curState)->init = newInit; \
(curState)->size = sizeof(newStruct); \
} while(0)
#define SET_FULLSCREEN_VIEWPORT(view) \
{ \
Viewport viewport; \
viewport.bottomY = SCREEN_HEIGHT; \
viewport.rightX = SCREEN_WIDTH; \
viewport.topY = 0; \
viewport.leftX = 0; \
View_SetViewport(view, &viewport); \
} \
(void)0
#define SET_FULLSCREEN_VIEWPORT(view) \
{ \
Viewport viewport; \
viewport.bottomY = SCREEN_HEIGHT; \
viewport.rightX = SCREEN_WIDTH; \
viewport.topY = 0; \
viewport.leftX = 0; \
View_SetViewport(view, &viewport); \
} \
(void)0
#define WORK_DISP __gfxCtx->work.p
#define POLY_OPA_DISP __gfxCtx->polyOpa.p
#define POLY_XLU_DISP __gfxCtx->polyXlu.p
#define OVERLAY_DISP __gfxCtx->overlay.p
#define WORK_DISP __gfxCtx->work.p
#define POLY_OPA_DISP __gfxCtx->polyOpa.p
#define POLY_XLU_DISP __gfxCtx->polyXlu.p
#define OVERLAY_DISP __gfxCtx->overlay.p
// __gfxCtx shouldn't be used directly.
// Use the DISP macros defined above when writing to display buffers.
#define OPEN_DISPS(gfxCtx, file, line) \
{ \
GraphicsContext* __gfxCtx; \
Gfx* dispRefs[4]; \
__gfxCtx = gfxCtx; \
(void)__gfxCtx; \
Graph_OpenDisps(dispRefs, gfxCtx, __FILE__, __LINE__)
#define OPEN_DISPS(gfxCtx, file, line) \
{ \
GraphicsContext* __gfxCtx; \
Gfx* dispRefs[4]; \
__gfxCtx = gfxCtx; \
(void)__gfxCtx; \
Graph_OpenDisps(dispRefs, gfxCtx, __FILE__, __LINE__)
#define CLOSE_DISPS(gfxCtx, file, line) \
Graph_CloseDisps(dispRefs, gfxCtx, __FILE__, __LINE__); \
} \
(void)0
#define CLOSE_DISPS(gfxCtx, file, line) \
Graph_CloseDisps(dispRefs, gfxCtx, __FILE__, __LINE__); \
} \
(void)0
/**
* `x` vertex x
@ -101,17 +98,30 @@
* `cbnz` blue component of color vertex, or z component of normal vertex
* `a` alpha
*/
#define VTX(x,y,z,s,t,crnx,cgny,cbnz,a) { { { (short)(x), (short)(y), (short)(z) }, 0, { (short)(s), (short)(t) }, { crnx, cgny, cbnz, a } } }
#define VTX(x, y, z, s, t, crnx, cgny, cbnz, a) \
{ \
{ \
{(short)(x), (short)(y), (short)(z)}, 0, {(short)(s), (short)(t)}, \
{ \
crnx, cgny, cbnz, a \
} \
} \
}
#define VTX_T(x,y,z,s,t,cr,cg,cb,a) { { x, y, z }, 0, { s, t }, { cr, cg, cb, a } }
#define VTX_T(x, y, z, s, t, cr, cg, cb, a) \
{ \
{x, y, z}, 0, {s, t}, \
{ \
cr, cg, cb, a \
} \
}
#define MES(n) (((n & 0xFFFF)) << 16) | ((n >> 16) & 0xFFFF)
#define MES(n) (((n & 0xFFFF)) << 16) | ((n >> 16) & 0xFFFF)
#define MTX(n00, n01, n02, n03, n10, n11, n12, n13, n20, n21, n22, n23, n30, n31, n32, n33) \
{MES(n00), MES(n01), MES(n02), MES(n03), \
MES(n10), MES(n11), MES(n12), MES(n13), \
MES(n20), MES(n21), MES(n22), MES(n23), \
MES(n30), MES(n31), MES(n32), MES(n33)}
#define MTX(n00, n01, n02, n03, n10, n11, n12, n13, n20, n21, n22, n23, n30, n31, n32, n33) \
{ \
MES(n00), MES(n01), MES(n02), MES(n03), MES(n10), MES(n11), MES(n12), MES(n13), MES(n20), MES(n21), MES(n22), MES(n23), MES(n30), MES(n31), MES(n32), MES(n33) \
}
#ifdef NDEBUG
#define ASSERT(cond, msg, file, line) ((void)0)
@ -121,21 +131,19 @@ MES(n30), MES(n31), MES(n32), MES(n33)}
#define ASSERT(cond, msg, file, line) ((cond) ? ((void)0) : oot_assert(msg, file, line))
#endif
#define gDPSetTileCustom(pkt, fmt, siz, width, height, pal, cms, cmt, masks, maskt, shifts, shiftt) \
do { \
gDPPipeSync(pkt); \
gDPTileSync(pkt); \
gDPSetTile(pkt, fmt, siz, (((width)*siz##_TILE_BYTES) + 7) >> 3, 0, G_TX_LOADTILE, 0, cmt, maskt, shiftt, cms, \
masks, shifts); \
gDPTileSync(pkt); \
gDPSetTile(pkt, fmt, siz, (((width)*siz##_TILE_BYTES) + 7) >> 3, 0, G_TX_RENDERTILE, pal, cmt, maskt, shiftt, \
cms, masks, shifts); \
gDPSetTileSize(pkt, G_TX_RENDERTILE, 0, 0, ((width)-1) << G_TEXTURE_IMAGE_FRAC, \
((height)-1) << G_TEXTURE_IMAGE_FRAC); \
} while (0)
#define gDPSetTileCustom(pkt, fmt, siz, width, height, pal, cms, cmt, masks, maskt, shifts, shiftt) \
do \
{ \
gDPPipeSync(pkt); \
gDPTileSync(pkt); \
gDPSetTile(pkt, fmt, siz, (((width)*siz##_TILE_BYTES) + 7) >> 3, 0, G_TX_LOADTILE, 0, cmt, maskt, shiftt, cms, masks, shifts); \
gDPTileSync(pkt); \
gDPSetTile(pkt, fmt, siz, (((width)*siz##_TILE_BYTES) + 7) >> 3, 0, G_TX_RENDERTILE, pal, cmt, maskt, shiftt, cms, masks, shifts); \
gDPSetTileSize(pkt, G_TX_RENDERTILE, 0, 0, ((width)-1) << G_TEXTURE_IMAGE_FRAC, ((height)-1) << G_TEXTURE_IMAGE_FRAC); \
} while(0)
#ifdef __GNUC__
#define ALIGNED8 __attribute__ ((aligned (8)))
#define ALIGNED8 __attribute__((aligned(8)))
#else
#define ALIGNED8
#endif
@ -155,11 +163,9 @@ MES(n30), MES(n31), MES(n32), MES(n33)}
#define RADTODEG(x) (x * 180.0 / M_PI)
#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif

240
include/message_data_fmt.h
View File

@ -21,91 +21,91 @@
// Control character magic values, in 2-digit hex without prefix
#define CTRL_NEWLINE 01
#define CTRL_END 02
#define CTRL_BOX_BREAK 04
#define CTRL_COLOR 05
#define CTRL_SHIFT 06
#define CTRL_TEXTID 07
#define CTRL_QUICKTEXT_ENABLE 08
#define CTRL_QUICKTEXT_DISABLE 09
#define CTRL_PERSISTENT 0A
#define CTRL_EVENT 0B
#define CTRL_BOX_BREAK_DELAYED 0C
#define CTRL_AWAIT_BUTTON_PRESS 0D
#define CTRL_FADE 0E
#define CTRL_NAME 0F
#define CTRL_OCARINA 10
#define CTRL_FADE2 11
#define CTRL_SFX 12
#define CTRL_ITEM_ICON 13
#define CTRL_TEXT_SPEED 14
#define CTRL_BACKGROUND 15
#define CTRL_MARATHON_TIME 16
#define CTRL_RACE_TIME 17
#define CTRL_POINTS 18
#define CTRL_TOKENS 19
#define CTRL_UNSKIPPABLE 1A
#define CTRL_TWO_CHOICE 1B
#define CTRL_THREE_CHOICE 1C
#define CTRL_FISH_INFO 1D
#define CTRL_HIGHSCORE 1E
#define CTRL_TIME 1F
#define CTRL_NEWLINE 01
#define CTRL_END 02
#define CTRL_BOX_BREAK 04
#define CTRL_COLOR 05
#define CTRL_SHIFT 06
#define CTRL_TEXTID 07
#define CTRL_QUICKTEXT_ENABLE 08
#define CTRL_QUICKTEXT_DISABLE 09
#define CTRL_PERSISTENT 0A
#define CTRL_EVENT 0B
#define CTRL_BOX_BREAK_DELAYED 0C
#define CTRL_AWAIT_BUTTON_PRESS 0D
#define CTRL_FADE 0E
#define CTRL_NAME 0F
#define CTRL_OCARINA 10
#define CTRL_FADE2 11
#define CTRL_SFX 12
#define CTRL_ITEM_ICON 13
#define CTRL_TEXT_SPEED 14
#define CTRL_BACKGROUND 15
#define CTRL_MARATHON_TIME 16
#define CTRL_RACE_TIME 17
#define CTRL_POINTS 18
#define CTRL_TOKENS 19
#define CTRL_UNSKIPPABLE 1A
#define CTRL_TWO_CHOICE 1B
#define CTRL_THREE_CHOICE 1C
#define CTRL_FISH_INFO 1D
#define CTRL_HIGHSCORE 1E
#define CTRL_TIME 1F
/*
* Colors
*/
*/
#define COLOR_STR(N) EXPAND_AND_STRINGIFY(GLUE(\x4, N))
// Color magic values, in single-digit hex without prefix
#define CTRL_DEFAULT 0
#define CTRL_RED 1
#define CTRL_DEFAULT 0
#define CTRL_RED 1
#define CTRL_ADJUSTABLE 2
#define CTRL_BLUE 3
#define CTRL_LIGHTBLUE 4
#define CTRL_PURPLE 5
#define CTRL_YELLOW 6
#define CTRL_BLACK 7
#define CTRL_BLUE 3
#define CTRL_LIGHTBLUE 4
#define CTRL_PURPLE 5
#define CTRL_YELLOW 6
#define CTRL_BLACK 7
#ifdef MESSAGE_DATA_STATIC
// For use in message_data_static files
#define ARG(x) x
// while a control character, newlines are handled in the charmap conversion
// while a control character, newlines are handled in the charmap conversion
// stage to allow normal newline \n usage in message_data_static files
#define NEWLINE STR(CTRL_NEWLINE)
#define END STR(CTRL_END)
#define BOX_BREAK STR(CTRL_BOX_BREAK)
#define COLOR(x) STR(CTRL_COLOR) ARG(x) // 1
#define SHIFT(x) STR(CTRL_SHIFT) ARG(x) // 1
#define TEXTID(x) STR(CTRL_TEXTID) ARG(x) // 2
#define QUICKTEXT_ENABLE STR(CTRL_QUICKTEXT_ENABLE)
#define QUICKTEXT_DISABLE STR(CTRL_QUICKTEXT_DISABLE)
#define PERSISTENT STR(CTRL_PERSISTENT)
#define EVENT STR(CTRL_EVENT)
#define BOX_BREAK_DELAYED(x) STR(CTRL_BOX_BREAK_DELAYED) ARG(x) // 1
#define AWAIT_BUTTON_PRESS STR(CTRL_AWAIT_BUTTON_PRESS)
#define FADE(x) STR(CTRL_FADE) ARG(x) // 1
#define NAME STR(CTRL_NAME)
#define OCARINA STR(CTRL_OCARINA)
#define FADE2(x) STR(CTRL_FADE2) ARG(x) // 2
#define SFX(x) STR(CTRL_SFX) ARG(x) // 2
#define ITEM_ICON(x) STR(CTRL_ITEM_ICON) ARG(x) // 1
#define TEXT_SPEED(x) STR(CTRL_TEXT_SPEED) ARG(x) // 1
#define BACKGROUND(x,y,z) STR(CTRL_BACKGROUND) ARG(x) ARG(y) ARG(z)
#define MARATHON_TIME STR(CTRL_MARATHON_TIME)
#define RACE_TIME STR(CTRL_RACE_TIME)
#define POINTS STR(CTRL_POINTS)
#define TOKENS STR(CTRL_TOKENS)
#define UNSKIPPABLE STR(CTRL_UNSKIPPABLE)
#define TWO_CHOICE STR(CTRL_TWO_CHOICE)
#define THREE_CHOICE STR(CTRL_THREE_CHOICE)
#define FISH_INFO STR(CTRL_FISH_INFO)
#define HIGHSCORE(x) STR(CTRL_HIGHSCORE) ARG(x) // 1
#define TIME STR(CTRL_TIME)
#define NEWLINE STR(CTRL_NEWLINE)
#define END STR(CTRL_END)
#define BOX_BREAK STR(CTRL_BOX_BREAK)
#define COLOR(x) STR(CTRL_COLOR) ARG(x) // 1
#define SHIFT(x) STR(CTRL_SHIFT) ARG(x) // 1
#define TEXTID(x) STR(CTRL_TEXTID) ARG(x) // 2
#define QUICKTEXT_ENABLE STR(CTRL_QUICKTEXT_ENABLE)
#define QUICKTEXT_DISABLE STR(CTRL_QUICKTEXT_DISABLE)
#define PERSISTENT STR(CTRL_PERSISTENT)
#define EVENT STR(CTRL_EVENT)
#define BOX_BREAK_DELAYED(x) STR(CTRL_BOX_BREAK_DELAYED) ARG(x) // 1
#define AWAIT_BUTTON_PRESS STR(CTRL_AWAIT_BUTTON_PRESS)
#define FADE(x) STR(CTRL_FADE) ARG(x) // 1
#define NAME STR(CTRL_NAME)
#define OCARINA STR(CTRL_OCARINA)
#define FADE2(x) STR(CTRL_FADE2) ARG(x) // 2
#define SFX(x) STR(CTRL_SFX) ARG(x) // 2
#define ITEM_ICON(x) STR(CTRL_ITEM_ICON) ARG(x) // 1
#define TEXT_SPEED(x) STR(CTRL_TEXT_SPEED) ARG(x) // 1
#define BACKGROUND(x, y, z) STR(CTRL_BACKGROUND) ARG(x) ARG(y) ARG(z)
#define MARATHON_TIME STR(CTRL_MARATHON_TIME)
#define RACE_TIME STR(CTRL_RACE_TIME)
#define POINTS STR(CTRL_POINTS)
#define TOKENS STR(CTRL_TOKENS)
#define UNSKIPPABLE STR(CTRL_UNSKIPPABLE)
#define TWO_CHOICE STR(CTRL_TWO_CHOICE)
#define THREE_CHOICE STR(CTRL_THREE_CHOICE)
#define FISH_INFO STR(CTRL_FISH_INFO)
#define HIGHSCORE(x) STR(CTRL_HIGHSCORE) ARG(x) // 1
#define TIME STR(CTRL_TIME)
/*
* Highscore values as strings, for code references the HighScores
@ -113,66 +113,66 @@
*/
#define HS_HORSE_ARCHERY "\x00"
#define HS_POE_POINTS "\x01"
#define HS_LARGEST_FISH "\x02"
#define HS_HORSE_RACE "\x03"
#define HS_MARATHON "\x04"
#define HS_DAMPE_RACE "\x06"
#define HS_POE_POINTS "\x01"
#define HS_LARGEST_FISH "\x02"
#define HS_HORSE_RACE "\x03"
#define HS_MARATHON "\x04"
#define HS_DAMPE_RACE "\x06"
/*
* Color values as strings
*/
#define DEFAULT COLOR_STR(CTRL_DEFAULT)
#define RED COLOR_STR(CTRL_RED)
#define ADJUSTABLE COLOR_STR(CTRL_ADJUSTABLE)
#define BLUE COLOR_STR(CTRL_BLUE)
#define LIGHTBLUE COLOR_STR(CTRL_LIGHTBLUE)
#define PURPLE COLOR_STR(CTRL_PURPLE)
#define YELLOW COLOR_STR(CTRL_YELLOW)
#define BLACK COLOR_STR(CTRL_BLACK)
#define DEFAULT COLOR_STR(CTRL_DEFAULT)
#define RED COLOR_STR(CTRL_RED)
#define ADJUSTABLE COLOR_STR(CTRL_ADJUSTABLE)
#define BLUE COLOR_STR(CTRL_BLUE)
#define LIGHTBLUE COLOR_STR(CTRL_LIGHTBLUE)
#define PURPLE COLOR_STR(CTRL_PURPLE)
#define YELLOW COLOR_STR(CTRL_YELLOW)
#define BLACK COLOR_STR(CTRL_BLACK)
#else
// For use in code files
#define MSGCOL_DEFAULT HEX(CTRL_DEFAULT)
#define MSGCOL_RED HEX(CTRL_RED)
#define MSGCOL_ADJUSTABLE HEX(CTRL_ADJUSTABLE)
#define MSGCOL_BLUE HEX(CTRL_BLUE)
#define MSGCOL_LIGHTBLUE HEX(CTRL_LIGHTBLUE)
#define MSGCOL_PURPLE HEX(CTRL_PURPLE)
#define MSGCOL_YELLOW HEX(CTRL_YELLOW)
#define MSGCOL_BLACK HEX(CTRL_BLACK)
#define MSGCOL_DEFAULT HEX(CTRL_DEFAULT)
#define MSGCOL_RED HEX(CTRL_RED)
#define MSGCOL_ADJUSTABLE HEX(CTRL_ADJUSTABLE)
#define MSGCOL_BLUE HEX(CTRL_BLUE)
#define MSGCOL_LIGHTBLUE HEX(CTRL_LIGHTBLUE)
#define MSGCOL_PURPLE HEX(CTRL_PURPLE)
#define MSGCOL_YELLOW HEX(CTRL_YELLOW)
#define MSGCOL_BLACK HEX(CTRL_BLACK)
#define MESSAGE_NEWLINE HEX(CTRL_NEWLINE)
#define MESSAGE_END HEX(CTRL_END)
#define MESSAGE_BOX_BREAK HEX(CTRL_BOX_BREAK)
#define MESSAGE_COLOR HEX(CTRL_COLOR)
#define MESSAGE_SHIFT HEX(CTRL_SHIFT)
#define MESSAGE_TEXTID HEX(CTRL_TEXTID)
#define MESSAGE_QUICKTEXT_ENABLE HEX(CTRL_QUICKTEXT_ENABLE)
#define MESSAGE_QUICKTEXT_DISABLE HEX(CTRL_QUICKTEXT_DISABLE)
#define MESSAGE_PERSISTENT HEX(CTRL_PERSISTENT)
#define MESSAGE_EVENT HEX(CTRL_EVENT)
#define MESSAGE_BOX_BREAK_DELAYED HEX(CTRL_BOX_BREAK_DELAYED)
#define MESSAGE_AWAIT_BUTTON_PRESS HEX(CTRL_AWAIT_BUTTON_PRESS)
#define MESSAGE_FADE HEX(CTRL_FADE)
#define MESSAGE_NAME HEX(CTRL_NAME)
#define MESSAGE_OCARINA HEX(CTRL_OCARINA)
#define MESSAGE_FADE2 HEX(CTRL_FADE2)
#define MESSAGE_SFX HEX(CTRL_SFX)
#define MESSAGE_ITEM_ICON HEX(CTRL_ITEM_ICON)
#define MESSAGE_TEXT_SPEED HEX(CTRL_TEXT_SPEED)
#define MESSAGE_BACKGROUND HEX(CTRL_BACKGROUND)
#define MESSAGE_MARATHON_TIME HEX(CTRL_MARATHON_TIME)
#define MESSAGE_RACE_TIME HEX(CTRL_RACE_TIME)
#define MESSAGE_POINTS HEX(CTRL_POINTS)
#define MESSAGE_TOKENS HEX(CTRL_TOKENS)
#define MESSAGE_UNSKIPPABLE HEX(CTRL_UNSKIPPABLE)
#define MESSAGE_TWO_CHOICE HEX(CTRL_TWO_CHOICE)
#define MESSAGE_THREE_CHOICE HEX(CTRL_THREE_CHOICE)
#define MESSAGE_FISH_INFO HEX(CTRL_FISH_INFO)
#define MESSAGE_HIGHSCORE HEX(CTRL_HIGHSCORE)
#define MESSAGE_TIME HEX(CTRL_TIME)
#define MESSAGE_NEWLINE HEX(CTRL_NEWLINE)
#define MESSAGE_END HEX(CTRL_END)
#define MESSAGE_BOX_BREAK HEX(CTRL_BOX_BREAK)
#define MESSAGE_COLOR HEX(CTRL_COLOR)
#define MESSAGE_SHIFT HEX(CTRL_SHIFT)
#define MESSAGE_TEXTID HEX(CTRL_TEXTID)
#define MESSAGE_QUICKTEXT_ENABLE HEX(CTRL_QUICKTEXT_ENABLE)
#define MESSAGE_QUICKTEXT_DISABLE HEX(CTRL_QUICKTEXT_DISABLE)
#define MESSAGE_PERSISTENT HEX(CTRL_PERSISTENT)
#define MESSAGE_EVENT HEX(CTRL_EVENT)
#define MESSAGE_BOX_BREAK_DELAYED HEX(CTRL_BOX_BREAK_DELAYED)
#define MESSAGE_AWAIT_BUTTON_PRESS HEX(CTRL_AWAIT_BUTTON_PRESS)
#define MESSAGE_FADE HEX(CTRL_FADE)
#define MESSAGE_NAME HEX(CTRL_NAME)
#define MESSAGE_OCARINA HEX(CTRL_OCARINA)
#define MESSAGE_FADE2 HEX(CTRL_FADE2)
#define MESSAGE_SFX HEX(CTRL_SFX)
#define MESSAGE_ITEM_ICON HEX(CTRL_ITEM_ICON)
#define MESSAGE_TEXT_SPEED HEX(CTRL_TEXT_SPEED)
#define MESSAGE_BACKGROUND HEX(CTRL_BACKGROUND)
#define MESSAGE_MARATHON_TIME HEX(CTRL_MARATHON_TIME)
#define MESSAGE_RACE_TIME HEX(CTRL_RACE_TIME)
#define MESSAGE_POINTS HEX(CTRL_POINTS)
#define MESSAGE_TOKENS HEX(CTRL_TOKENS)
#define MESSAGE_UNSKIPPABLE HEX(CTRL_UNSKIPPABLE)
#define MESSAGE_TWO_CHOICE HEX(CTRL_TWO_CHOICE)
#define MESSAGE_THREE_CHOICE HEX(CTRL_THREE_CHOICE)
#define MESSAGE_FISH_INFO HEX(CTRL_FISH_INFO)
#define MESSAGE_HIGHSCORE HEX(CTRL_HIGHSCORE)
#define MESSAGE_TIME HEX(CTRL_TIME)
#endif
#endif

58
include/message_data_static.h
View File

@ -4,54 +4,56 @@
#include "global.h"
#include "message_data_fmt.h"
enum TextBoxType {
/* 0 */ TEXTBOX_TYPE_BLACK,
/* 1 */ TEXTBOX_TYPE_WOODEN,
/* 2 */ TEXTBOX_TYPE_BLUE,
/* 3 */ TEXTBOX_TYPE_OCARINA,
/* 4 */ TEXTBOX_TYPE_NONE_BOTTOM,
/* 5 */ TEXTBOX_TYPE_NONE_NO_SHADOW,
/* 11 */ TEXTBOX_TYPE_CREDITS = 11
enum TextBoxType
{
/* 0 */ TEXTBOX_TYPE_BLACK,
/* 1 */ TEXTBOX_TYPE_WOODEN,
/* 2 */ TEXTBOX_TYPE_BLUE,
/* 3 */ TEXTBOX_TYPE_OCARINA,
/* 4 */ TEXTBOX_TYPE_NONE_BOTTOM,
/* 5 */ TEXTBOX_TYPE_NONE_NO_SHADOW,
/* 11 */ TEXTBOX_TYPE_CREDITS = 11
};
enum TextBoxBackground {
/* 0 */ TEXTBOX_BG_CROSS
enum TextBoxBackground
{
/* 0 */ TEXTBOX_BG_CROSS
};
enum TextBoxPosition {
/* 0 */ TEXTBOX_POS_VARIABLE,
/* 1 */ TEXTBOX_POS_TOP,
/* 2 */ TEXTBOX_POS_BOTTOM,
/* 3 */ TEXTBOX_POS_MIDDLE
enum TextBoxPosition
{
/* 0 */ TEXTBOX_POS_VARIABLE,
/* 1 */ TEXTBOX_POS_TOP,
/* 2 */ TEXTBOX_POS_BOTTOM,
/* 3 */ TEXTBOX_POS_MIDDLE
};
struct MessageTableEntry {
u16 textId;
u8 typePos;
const char* segment;
u32 length;
struct MessageTableEntry
{
u16 textId;
u8 typePos;
const char* segment;
u32 length;
};
/*
/*
* Message Symbol Declarations
*/
#define DEFINE_MESSAGE(textId, type, yPos, staffMessage) \
extern "C" const char _message_##textId##_staff[];
#define DEFINE_MESSAGE(textId, type, yPos, staffMessage) extern "C" const char _message_##textId##_staff[];
#include "text/message_data_staff.h"
#undef DEFINE_MESSAGE
#define DEFINE_MESSAGE(textId, type, yPos, nesMessage, gerMessage, fraMessage) \
extern "C" const char _message_##textId##_nes[]; \
extern "C" const char _message_##textId##_ger[]; \
extern "C" const char _message_##textId##_fra[];
#define DEFINE_MESSAGE(textId, type, yPos, nesMessage, gerMessage, fraMessage) \
extern "C" const char _message_##textId##_nes[]; \
extern "C" const char _message_##textId##_ger[]; \
extern "C" const char _message_##textId##_fra[];
#include "text/message_data.h"
extern "C" const char _message_0xFFFC_nes[73];
#undef DEFINE_MESSAGE
#endif

32
include/mixer.h
View File

@ -46,35 +46,34 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRA
#undef aUnkCmd3
#undef aUnkCmd19
void aClearBufferImpl(uint16_t addr, int nbytes);
void aLoadBufferImpl(const void *source_addr, uint16_t dest_addr, uint16_t nbytes);
void aSaveBufferImpl(uint16_t source_addr, int16_t *dest_addr, uint16_t nbytes);
void aLoadADPCMImpl(int num_entries_times_16, const int16_t *book_source_addr);
void aLoadBufferImpl(const void* source_addr, uint16_t dest_addr, uint16_t nbytes);
void aSaveBufferImpl(uint16_t source_addr, int16_t* dest_addr, uint16_t nbytes);
void aLoadADPCMImpl(int num_entries_times_16, const int16_t* book_source_addr);
void aSetBufferImpl(uint8_t flags, uint16_t in, uint16_t out, uint16_t nbytes);
void aInterleaveImpl(uint16_t dest, uint16_t left, uint16_t right, uint16_t c);
void aDMEMMoveImpl(uint16_t in_addr, uint16_t out_addr, int nbytes);
void aSetLoopImpl(ADPCM_STATE *adpcm_loop_state);
void aSetLoopImpl(ADPCM_STATE* adpcm_loop_state);
void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state);
void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state);
void aEnvSetup1Impl(uint8_t initial_vol_wet, uint16_t rate_wet, uint16_t rate_left, uint16_t rate_right);
void aEnvSetup2Impl(uint16_t initial_vol_left, uint16_t initial_vol_right);
void aEnvMixerImpl(uint16_t in_addr, uint16_t n_samples, bool swap_reverb,
bool neg_3, bool neg_2,
bool neg_left, bool neg_right,
int32_t wet_dry_addr, u32 unk);
void aEnvMixerImpl(uint16_t in_addr, uint16_t n_samples, bool swap_reverb, bool neg_3, bool neg_2, bool neg_left, bool neg_right, int32_t wet_dry_addr, u32 unk);
void aMixImpl(uint16_t count, int16_t gain, uint16_t in_addr, uint16_t out_addr);
void aS8DecImpl(uint8_t flags, ADPCM_STATE state);
void aAddMixerImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count);
void aDuplicateImpl(uint16_t count, uint16_t in_addr, uint16_t out_addr);
void aResampleZohImpl(uint16_t pitch, uint16_t start_fract);
void aInterlImpl(uint16_t in_addr, uint16_t out_addr, uint16_t n_samples);
void aFilterImpl(uint8_t flags, uint16_t count_or_buf, int16_t *state_or_filter);
void aFilterImpl(uint8_t flags, uint16_t count_or_buf, int16_t* state_or_filter);
void aHiLoGainImpl(uint8_t g, uint16_t count, uint16_t addr);
void aUnkCmd3Impl(uint16_t a, uint16_t b, uint16_t c);
void aUnkCmd19Impl(uint8_t f, uint16_t count, uint16_t out_addr, uint16_t in_addr);
#define aSegment(pkt, s, b) do { } while(0)
#define aSegment(pkt, s, b) \
do \
{ \
} while(0)
#define aClearBuffer(pkt, d, c) aClearBufferImpl(d, c)
#define aLoadBuffer(pkt, s, d, c) aLoadBufferImpl(s, d, c)
#define aSaveBuffer(pkt, s, d, c) aSaveBufferImpl(s, d, c)
@ -85,14 +84,9 @@ void aUnkCmd19Impl(uint8_t f, uint16_t count, uint16_t out_addr, uint16_t in_add
#define aSetLoop(pkt, a) aSetLoopImpl(a)
#define aADPCMdec(pkt, f, s) aADPCMdecImpl(f, s)
#define aResample(pkt, f, p, s) aResampleImpl(f, p, (short*)s)
#define aEnvSetup1(pkt, initialVolReverb, rampReverb, rampLeft, rampRight) \
aEnvSetup1Impl(initialVolReverb, rampReverb, rampLeft, rampRight)
#define aEnvSetup2(pkt, initialVolLeft, initialVolRight) \
aEnvSetup2Impl(initialVolLeft, initialVolRight)
#define aEnvMixer(pkt, inBuf, nSamples, swapReverb, negLeft, negRight, \
dryLeft, dryRight, wetLeft, wetRight) \
aEnvMixerImpl(inBuf, nSamples, swapReverb, negLeft, negRight, \
dryLeft, dryRight, wetLeft, wetRight)
#define aEnvSetup1(pkt, initialVolReverb, rampReverb, rampLeft, rampRight) aEnvSetup1Impl(initialVolReverb, rampReverb, rampLeft, rampRight)
#define aEnvSetup2(pkt, initialVolLeft, initialVolRight) aEnvSetup2Impl(initialVolLeft, initialVolRight)
#define aEnvMixer(pkt, inBuf, nSamples, swapReverb, negLeft, negRight, dryLeft, dryRight, wetLeft, wetRight) aEnvMixerImpl(inBuf, nSamples, swapReverb, negLeft, negRight, dryLeft, dryRight, wetLeft, wetRight)
#define aMix(pkt, c, g, i, o) aMixImpl(c, g, i, o)
#define aS8Dec(pkt, f, s) aS8DecImpl(f, s)
#define aAddMixer(pkt, s, d, c) aAddMixerImpl(s, d, c)

121
include/n64fault.h
View File

@ -1,70 +1,75 @@
#pragma once
#include "ultra64/types.h"
#include "ultra64/sched.h"
#include "padmgr.h"
#include "ultra64/sched.h"
#include "ultra64/types.h"
struct FaultClient {
/* 0x00 */ struct FaultClient* next;
/* 0x04 */ u32 callback;
/* 0x08 */ u32 param1;
/* 0x0C */ u32 param2;
struct FaultClient
{
/* 0x00 */ struct FaultClient* next;
/* 0x04 */ u32 callback;
/* 0x08 */ u32 param1;
/* 0x0C */ u32 param2;
}; // size = 0x10
struct FaultAddrConvClient {
/* 0x00 */ struct FaultAddrConvClient* next;
/* 0x04 */ u32 callback;
/* 0x08 */ u32 param;
struct FaultAddrConvClient
{
/* 0x00 */ struct FaultAddrConvClient* next;
/* 0x04 */ u32 callback;
/* 0x08 */ u32 param;
}; // size = 0xC
struct FaultClientContext {
/* 0x00 */ u32 (*callback)(u32, u32);
/* 0x04 */ u32 param0;
/* 0x08 */ u32 param1;
/* 0x0C */ u32 ret;
/* 0x10 */ OSMesgQueue* queue;
/* 0x14 */ OSMesg msg;
struct FaultClientContext
{
/* 0x00 */ u32 (*callback)(u32, u32);
/* 0x04 */ u32 param0;
/* 0x08 */ u32 param1;
/* 0x0C */ u32 ret;
/* 0x10 */ OSMesgQueue* queue;
/* 0x14 */ OSMesg msg;
}; // size = 0x18
struct FaultThreadStruct {
/* 0x000 */ OSThread thread;
/* 0x1B0 */ u8 unk_1B0[0x600];
/* 0x7B0 */ OSMesgQueue queue;
/* 0x7C8 */ OSMesg msg;
/* 0x7CC */ u8 exitDebugger;
/* 0x7CD */ u8 msgId;
/* 0x7CE */ u8 faultHandlerEnabled;
/* 0x7CF */ u8 faultActive;
/* 0x7D0 */ OSThread* faultedThread;
/* 0x7D4 */ void (*padCallback)(Input*);
/* 0x7D8 */ FaultClient* clients;
/* 0x7DC */ FaultAddrConvClient* addrConvClients;
/* 0x7E0 */ u8 unk_7E0[4];
/* 0x7E4 */ Input padInput;
/* 0x7FC */ u16 colors[36];
/* 0x844 */ void* fb;
/* 0x848 */ u32 currClientThreadSp;
/* 0x84C */ u8 unk_84C[4];
struct FaultThreadStruct
{
/* 0x000 */ OSThread thread;
/* 0x1B0 */ u8 unk_1B0[0x600];
/* 0x7B0 */ OSMesgQueue queue;
/* 0x7C8 */ OSMesg msg;
/* 0x7CC */ u8 exitDebugger;
/* 0x7CD */ u8 msgId;
/* 0x7CE */ u8 faultHandlerEnabled;
/* 0x7CF */ u8 faultActive;
/* 0x7D0 */ OSThread* faultedThread;
/* 0x7D4 */ void (*padCallback)(Input*);
/* 0x7D8 */ FaultClient* clients;
/* 0x7DC */ FaultAddrConvClient* addrConvClients;
/* 0x7E0 */ u8 unk_7E0[4];
/* 0x7E4 */ Input padInput;
/* 0x7FC */ u16 colors[36];
/* 0x844 */ void* fb;
/* 0x848 */ u32 currClientThreadSp;
/* 0x84C */ u8 unk_84C[4];
}; // size = 0x850
struct FaultDrawer {
/* 0x00 */ u16* fb;
/* 0x04 */ u16 w;
/* 0x08 */ u16 h;
/* 0x0A */ u16 yStart;
/* 0x0C */ u16 yEnd;
/* 0x0E */ u16 xStart;
/* 0x10 */ u16 xEnd;
/* 0x12 */ u16 foreColor;
/* 0x14 */ u16 backColor;
/* 0x14 */ u16 cursorX;
/* 0x16 */ u16 cursorY;
/* 0x18 */ const u32* fontData;
/* 0x1C */ u8 charW;
/* 0x1D */ u8 charH;
/* 0x1E */ s8 charWPad;
/* 0x1F */ s8 charHPad;
/* 0x20 */ u16 printColors[10];
/* 0x34 */ u8 escCode; // bool
/* 0x35 */ u8 osSyncPrintfEnabled;
/* 0x38 */ void (*inputCallback)();
struct FaultDrawer
{
/* 0x00 */ u16* fb;
/* 0x04 */ u16 w;
/* 0x08 */ u16 h;
/* 0x0A */ u16 yStart;
/* 0x0C */ u16 yEnd;
/* 0x0E */ u16 xStart;
/* 0x10 */ u16 xEnd;
/* 0x12 */ u16 foreColor;
/* 0x14 */ u16 backColor;
/* 0x14 */ u16 cursorX;
/* 0x16 */ u16 cursorY;
/* 0x18 */ const u32* fontData;
/* 0x1C */ u8 charW;
/* 0x1D */ u8 charH;
/* 0x1E */ s8 charWPad;
/* 0x1F */ s8 charHPad;
/* 0x20 */ u16 printColors[10];
/* 0x34 */ u8 escCode; // bool
/* 0x35 */ u8 osSyncPrintfEnabled;
/* 0x38 */ void (*inputCallback)();
}; // size = 0x3C

99
include/n64mapdata.h
View File

@ -1,59 +1,60 @@
#pragma once
#include "ultra64/types.h"
enum FloorID {
/* 1 */ F_8F = 1,
/* 2 */ F_7F,
/* 3 */ F_6F,
/* 4 */ F_5F,
/* 5 */ F_4F,
/* 6 */ F_3F,
/* 7 */ F_2F,
/* 8 */ F_1F,
/* 9 */ F_B1,
/* 10 */ F_B2,
/* 11 */ F_B3,
/* 12 */ F_B4,
/* 13 */ F_B5,
/* 14 */ F_B6,
/* 15 */ F_B7,
/* 16 */ F_B8
enum FloorID
{
/* 1 */ F_8F = 1,
/* 2 */ F_7F,
/* 3 */ F_6F,
/* 4 */ F_5F,
/* 5 */ F_4F,
/* 6 */ F_3F,
/* 7 */ F_2F,
/* 8 */ F_1F,
/* 9 */ F_B1,
/* 10 */ F_B2,
/* 11 */ F_B3,
/* 12 */ F_B4,
/* 13 */ F_B5,
/* 14 */ F_B6,
/* 15 */ F_B7,
/* 16 */ F_B8
};
// All arrays pointed in this struct are indexed by "map indexes"
// In dungeons, the map index corresponds to the dungeon index (which also indexes keys, items, etc)
// In overworld areas, the map index corresponds to the overworld area index (spot 00, 01, etc)
struct MapData {
/* 0x00 */ s16 (*floorTexIndexOffset)[8]; // dungeon texture index offset by floor
/* 0x04 */ s16* bossFloor; // floor the boss is on
/* 0x08 */ s16 (*roomPalette)[32]; // map palette by room
/* 0x0C */ s16* maxPaletteCount; // max number of palettes in a same floor
/* 0x10 */ s16 (*paletteRoom)[8][14]; // room by palette by floor
/* 0x14 */ s16 (*roomCompassOffsetX)[44]; // dungeon compass icon X offset by room
/* 0x18 */ s16 (*roomCompassOffsetY)[44]; // dungeon compass icon Y offset by room
/* 0x1C */ u8* dgnMinimapCount; // number of room minimaps
/* 0x20 */ u16* dgnMinimapTexIndexOffset; // dungeon minimap texture index offset
/* 0x24 */ u16* owMinimapTexSize;
/* 0x28 */ u16* owMinimapTexOffset;
/* 0x2C */ s16* owMinimapPosX;
/* 0x30 */ s16* owMinimapPosY;
/* 0x34 */ s16 (*owCompassInfo)[4]; // [X scale, Y scale, X offset, Y offset]
/* 0x38 */ s16* dgnMinimapTexIndexBase; // dungeon minimap texture index base
/* 0x3C */ s16 (*dgnCompassInfo)[4]; // [X scale, Y scale, X offset, Y offset]
/* 0x40 */ s16* owMinimapWidth;
/* 0x44 */ s16* owMinimapHeight;
/* 0x48 */ s16* owEntranceIconPosX; // "dungeon entrance" icon X pos
/* 0x4C */ s16* owEntranceIconPosY; // "dungeon entrance" icon Y pos
/* 0x50 */ u16*
owEntranceFlag; // flag in inf_table[26] based on which entrance icons are shown (0xFFFF = always shown)
/* 0x54 */ f32 (*floorCoordY)[8]; // Y coordinate of each floor
/* 0x58 */ u16* switchEntryCount; // number of "room switch" entries, which correspond to the next 3 arrays
/* 0x5C */ u8 (*switchFromRoom)[51]; // room to come from
/* 0x60 */ u8 (*switchFromFloor)[51]; // floor to come from
/* 0x64 */ u8 (*switchToRoom)[51]; // room to go to
/* 0x68 */ u8 (*floorID)[8];
/* 0x6C */ s16* skullFloorIconY; // dungeon big skull icon Y pos
}; // size = 0x70
struct MapData
{
/* 0x00 */ s16 (*floorTexIndexOffset)[8]; // dungeon texture index offset by floor
/* 0x04 */ s16* bossFloor; // floor the boss is on
/* 0x08 */ s16 (*roomPalette)[32]; // map palette by room
/* 0x0C */ s16* maxPaletteCount; // max number of palettes in a same floor
/* 0x10 */ s16 (*paletteRoom)[8][14]; // room by palette by floor
/* 0x14 */ s16 (*roomCompassOffsetX)[44]; // dungeon compass icon X offset by room
/* 0x18 */ s16 (*roomCompassOffsetY)[44]; // dungeon compass icon Y offset by room
/* 0x1C */ u8* dgnMinimapCount; // number of room minimaps
/* 0x20 */ u16* dgnMinimapTexIndexOffset; // dungeon minimap texture index offset
/* 0x24 */ u16* owMinimapTexSize;
/* 0x28 */ u16* owMinimapTexOffset;
/* 0x2C */ s16* owMinimapPosX;
/* 0x30 */ s16* owMinimapPosY;
/* 0x34 */ s16 (*owCompassInfo)[4]; // [X scale, Y scale, X offset, Y offset]
/* 0x38 */ s16* dgnMinimapTexIndexBase; // dungeon minimap texture index base
/* 0x3C */ s16 (*dgnCompassInfo)[4]; // [X scale, Y scale, X offset, Y offset]
/* 0x40 */ s16* owMinimapWidth;
/* 0x44 */ s16* owMinimapHeight;
/* 0x48 */ s16* owEntranceIconPosX; // "dungeon entrance" icon X pos
/* 0x4C */ s16* owEntranceIconPosY; // "dungeon entrance" icon Y pos
/* 0x50 */ u16* owEntranceFlag; // flag in inf_table[26] based on which entrance icons are shown (0xFFFF = always shown)
/* 0x54 */ f32 (*floorCoordY)[8]; // Y coordinate of each floor
/* 0x58 */ u16* switchEntryCount; // number of "room switch" entries, which correspond to the next 3 arrays
/* 0x5C */ u8 (*switchFromRoom)[51]; // room to come from
/* 0x60 */ u8 (*switchFromFloor)[51]; // floor to come from
/* 0x64 */ u8 (*switchToRoom)[51]; // room to go to
/* 0x68 */ u8 (*floorID)[8];
/* 0x6C */ s16* skullFloorIconY; // dungeon big skull icon Y pos
}; // size = 0x70
void Map_SavePlayerInitialInfo(struct GlobalContext* globalCtx);
void Map_SetFloorPalettesData(struct GlobalContext* globalCtx, s16 floor);
@ -65,4 +66,4 @@ void Minimap_Draw(struct GlobalContext* globalCtx);
void Map_Update(struct GlobalContext* globalCtx);
extern MapData gMapDataTable;
extern MapData * gMapData;
extern MapData* gMapData;

95
include/padmgr.h
View File

@ -1,59 +1,62 @@
#pragma once
#include <functional>
#include "ultra64/sched.h"
#include "ultra64/controller.h"
#include "ultra64/pfs.h"
#include "ultra64/sched.h"
struct Input {
/* 0x00 */ OSContPad cur;
/* 0x06 */ OSContPad prev;
/* 0x0C */ OSContPad press; // X/Y store delta from last frame
/* 0x12 */ OSContPad rel; // X/Y store adjusted
}; // size = 0x18
struct Input
{
/* 0x00 */ OSContPad cur;
/* 0x06 */ OSContPad prev;
/* 0x0C */ OSContPad press; // X/Y store delta from last frame
/* 0x12 */ OSContPad rel; // X/Y store adjusted
}; // size = 0x18
struct PadMgr {
/* 0x0000 */ OSContStatus padStatus[4];
/* 0x0010 */ OSMesg serialMsgBuf[1];
/* 0x0014 */ OSMesg lockMsgBuf[1];
/* 0x0018 */ OSMesg interruptMsgBuf[4];
/* 0x0028 */ OSMesgQueue serialMsgQ;
/* 0x0040 */ OSMesgQueue lockMsgQ;
/* 0x0058 */ OSMesgQueue interruptMsgQ;
/* 0x0070 */ IrqMgrClient irqClient;
/* 0x0078 */ IrqMgr* irqMgr;
/* 0x0080 */ OSThread thread;
/* 0x0230 */ Input inputs[4];
/* 0x0290 */ OSContPad pads[4];
/* 0x02A8 */ vu8 validCtrlrsMask;
/* 0x02A9 */ u8 nControllers;
/* 0x02AA */ u8 ctrlrIsConnected[4]; // "Key_switch" originally
/* 0x02AE */ u8 pakType[4]; // 1 if rumble pack, 2 if mempak?
/* 0x02B2 */ vu8 rumbleOn[4];
/* 0x02B6 */ u8 rumbleCounter[4]; // not clear exact meaning
/* 0x02BC */ OSPfs pfs[4];
/* 0x045C */ vu8 rumbleOffFrames;
/* 0x045D */ vu8 rumbleOnFrames;
/* 0x045E */ u8 preNMIShutdown;
/* 0x0460 */ void (*retraceCallback)(struct PadMgr* padmgr, s32 unk464);
/* 0x0464 */ u32 retraceCallbackValue;
struct PadMgr
{
/* 0x0000 */ OSContStatus padStatus[4];
/* 0x0010 */ OSMesg serialMsgBuf[1];
/* 0x0014 */ OSMesg lockMsgBuf[1];
/* 0x0018 */ OSMesg interruptMsgBuf[4];
/* 0x0028 */ OSMesgQueue serialMsgQ;
/* 0x0040 */ OSMesgQueue lockMsgQ;
/* 0x0058 */ OSMesgQueue interruptMsgQ;
/* 0x0070 */ IrqMgrClient irqClient;
/* 0x0078 */ IrqMgr* irqMgr;
/* 0x0080 */ OSThread thread;
/* 0x0230 */ Input inputs[4];
/* 0x0290 */ OSContPad pads[4];
/* 0x02A8 */ vu8 validCtrlrsMask;
/* 0x02A9 */ u8 nControllers;
/* 0x02AA */ u8 ctrlrIsConnected[4]; // "Key_switch" originally
/* 0x02AE */ u8 pakType[4]; // 1 if rumble pack, 2 if mempak?
/* 0x02B2 */ vu8 rumbleOn[4];
/* 0x02B6 */ u8 rumbleCounter[4]; // not clear exact meaning
/* 0x02BC */ OSPfs pfs[4];
/* 0x045C */ vu8 rumbleOffFrames;
/* 0x045D */ vu8 rumbleOnFrames;
/* 0x045E */ u8 preNMIShutdown;
/* 0x0460 */ void (*retraceCallback)(struct PadMgr* padmgr, s32 unk464);
/* 0x0464 */ u32 retraceCallbackValue;
}; // size = 0x468
struct RumbleStruct {
/* 0x000 */ u8 rumbleOn[4];//0 or 1 depending if rumble is happening right now
/* 0x004 */ u8 strengthList[0x40];//rumble pattern
/* 0x044 */ u8 lengthList[0x40];//rumble pattern
/* 0x084 */ u8 decayList[0x40];//rumble pattern
/* 0x0C4 */ u8 strengthList_easing[0x40];//Used internally to make the decay in more quadratic instead of linear
struct RumbleStruct
{
/* 0x000 */ u8 rumbleOn[4]; // 0 or 1 depending if rumble is happening right now
/* 0x004 */ u8 strengthList[0x40]; // rumble pattern
/* 0x044 */ u8 lengthList[0x40]; // rumble pattern
/* 0x084 */ u8 decayList[0x40]; // rumble pattern
/* 0x0C4 */ u8 strengthList_easing[0x40]; // Used internally to make the decay in more quadratic instead of linear
/* 0x104 */ u8 state;//set to 0 for a clear of all rumble data (rumble stops), set to 1 to continue operation, set to 2 for a full rumble device clear
/* 0x105 */ u8 reset;//set to zero to reset pakType of pad manager
/* 0x106 */ u16 timer1;//Counts up for each frame there is rumble, after 7200 frames ~ 6 minutes clears the rumble data
/* 0x108 */ u16 timer2;//Resets timer1 when there is no rumble
/* 0x104 */ u8 state; // set to 0 for a clear of all rumble data (rumble stops), set to 1 to continue operation, set to 2 for a full rumble device clear
/* 0x105 */ u8 reset; // set to zero to reset pakType of pad manager
/* 0x106 */ u16 timer1; // Counts up for each frame there is rumble, after 7200 frames ~ 6 minutes clears the rumble data
/* 0x108 */ u16 timer2; // Resets timer1 when there is no rumble
/* 0x10A */ u8 strength;
/* 0x10B */ u8 length;
/* 0x10C */ u8 decay;
/* 0x10D */ u8 strength_easing;
/* 0x10A */ u8 strength;
/* 0x10B */ u8 length;
/* 0x10C */ u8 decay;
/* 0x10D */ u8 strength_easing;
}; // size = 0x10E
extern PadMgr gPadMgr;

126
include/player_state.h
View File

@ -2,74 +2,74 @@
enum PlayerState1
{
PLAYER_STATE1_0 = 1 << 0, // 0x00000001
PLAYER_STATE1_1 = 1 << 1, // 0x00000002
PLAYER_STATE1_2 = 1 << 2, // 0x00000004
PLAYER_STATE1_3 = 1 << 3, // 0x00000008
PLAYER_STATE1_4 = 1 << 4, // 0x00000010
PLAYER_STATE1_5 = 1 << 5, // 0x00000020
PLAYER_STATE1_6 = 1 << 6, // 0x00000040
PLAYER_STATE1_7 = 1 << 7, // 0x00000080
PLAYER_STATE1_8 = 1 << 8, // 0x00000100
PLAYER_STATE1_9 = 1 << 9, // 0x00000200
PLAYER_STATE1_10 = 1 << 10, // 0x00000400
PLAYER_STATE1_11 = 1 << 11, // 0x00000800
PLAYER_STATE_SWORD_CHARGE = 1 << 12, // 0x00001000
PLAYER_STATE1_13 = 1 << 13, // 0x00002000
PLAYER_STATE1_14 = 1 << 14, // 0x00004000
PLAYER_STATE1_15 = 1 << 15, // 0x00008000
PLAYER_STATE1_16 = 1 << 16, // 0x00010000
PLAYER_STATE1_17 = 1 << 17, // 0x00020000
PLAYER_STATE1_18 = 1 << 18, // 0x00040000
PLAYER_STATE1_19 = 1 << 19, // 0x00080000
PLAYER_STATE1_20 = 1 << 20, // 0x00100000
PLAYER_STATE1_21 = 1 << 21, // 0x00200000
PLAYER_STATE1_22 = 1 << 22, // 0x00400000
PLAYER_STATE_HORSE_MOUNTED = 1 << 23, // 0x00800000
PLAYER_STATE1_24 = 1 << 24, // 0x01000000
PLAYER_STATE1_25 = 1 << 25, // 0x02000000
PLAYER_STATE1_26 = 1 << 26, // 0x04000000
PLAYER_STATE_SWIMMING = 1 << 27, // 0x08000000
PLAYER_STATE1_28 = 1 << 28, // 0x10000000
PLAYER_STATE1_29 = 1 << 29, // 0x20000000
PLAYER_STATE1_30 = 1 << 30, // 0x40000000
PLAYER_STATE1_31 = 1 << 31, // 0x80000000
PLAYER_STATE1_0 = 1 << 0, // 0x00000001
PLAYER_STATE1_1 = 1 << 1, // 0x00000002
PLAYER_STATE1_2 = 1 << 2, // 0x00000004
PLAYER_STATE1_3 = 1 << 3, // 0x00000008
PLAYER_STATE1_4 = 1 << 4, // 0x00000010
PLAYER_STATE1_5 = 1 << 5, // 0x00000020
PLAYER_STATE1_6 = 1 << 6, // 0x00000040
PLAYER_STATE1_7 = 1 << 7, // 0x00000080
PLAYER_STATE1_8 = 1 << 8, // 0x00000100
PLAYER_STATE1_9 = 1 << 9, // 0x00000200
PLAYER_STATE1_10 = 1 << 10, // 0x00000400
PLAYER_STATE1_11 = 1 << 11, // 0x00000800
PLAYER_STATE_SWORD_CHARGE = 1 << 12, // 0x00001000
PLAYER_STATE1_13 = 1 << 13, // 0x00002000
PLAYER_STATE1_14 = 1 << 14, // 0x00004000
PLAYER_STATE1_15 = 1 << 15, // 0x00008000
PLAYER_STATE1_16 = 1 << 16, // 0x00010000
PLAYER_STATE1_17 = 1 << 17, // 0x00020000
PLAYER_STATE1_18 = 1 << 18, // 0x00040000
PLAYER_STATE1_19 = 1 << 19, // 0x00080000
PLAYER_STATE1_20 = 1 << 20, // 0x00100000
PLAYER_STATE1_21 = 1 << 21, // 0x00200000
PLAYER_STATE1_22 = 1 << 22, // 0x00400000
PLAYER_STATE_HORSE_MOUNTED = 1 << 23, // 0x00800000
PLAYER_STATE1_24 = 1 << 24, // 0x01000000
PLAYER_STATE1_25 = 1 << 25, // 0x02000000
PLAYER_STATE1_26 = 1 << 26, // 0x04000000
PLAYER_STATE_SWIMMING = 1 << 27, // 0x08000000
PLAYER_STATE1_28 = 1 << 28, // 0x10000000
PLAYER_STATE1_29 = 1 << 29, // 0x20000000
PLAYER_STATE1_30 = 1 << 30, // 0x40000000
PLAYER_STATE1_31 = 1 << 31, // 0x80000000
};
enum PlayerState2
{
PLAYER_STATE2_0 = 1 << 0, // 0x00000001
PLAYER_STATE2_1 = 1 << 1, // 0x00000002
PLAYER_STATE2_2 = 1 << 2, // 0x00000004
PLAYER_STATE2_3 = 1 << 3, // 0x00000008
PLAYER_STATE2_4 = 1 << 4, // 0x00000010
PLAYER_STATE2_5 = 1 << 5, // 0x00000020
PLAYER_STATE2_REDIRECT_CONTROL = 1 << 6, // 0x00000040
PLAYER_STATE2_7 = 1 << 7, // 0x00000080
PLAYER_STATE2_8 = 1 << 8, // 0x00000100
PLAYER_STATE2_9 = 1 << 9, // 0x00000200
PLAYER_STATE2_10 = 1 << 10, // 0x00000400
PLAYER_STATE2_11 = 1 << 11, // 0x00000800
PLAYER_STATE2_12 = 1 << 12, // 0x00001000
PLAYER_STATE2_0 = 1 << 0, // 0x00000001
PLAYER_STATE2_1 = 1 << 1, // 0x00000002
PLAYER_STATE2_2 = 1 << 2, // 0x00000004
PLAYER_STATE2_3 = 1 << 3, // 0x00000008
PLAYER_STATE2_4 = 1 << 4, // 0x00000010
PLAYER_STATE2_5 = 1 << 5, // 0x00000020
PLAYER_STATE2_REDIRECT_CONTROL = 1 << 6, // 0x00000040
PLAYER_STATE2_7 = 1 << 7, // 0x00000080
PLAYER_STATE2_8 = 1 << 8, // 0x00000100
PLAYER_STATE2_9 = 1 << 9, // 0x00000200
PLAYER_STATE2_10 = 1 << 10, // 0x00000400
PLAYER_STATE2_11 = 1 << 11, // 0x00000800
PLAYER_STATE2_12 = 1 << 12, // 0x00001000
PLAYER_STATE2_ZTARGET_CHANGED = 1 << 13, // 0x00002000
PLAYER_STATE2_14 = 1 << 14, // 0x00004000
PLAYER_STATE2_15 = 1 << 15, // 0x00008000
PLAYER_STATE2_16 = 1 << 16, // 0x00010000
PLAYER_STATE2_17 = 1 << 17, // 0x00020000
PLAYER_STATE2_CRAWL = 1 << 18, // 0x00040000
PLAYER_STATE2_19 = 1 << 19, // 0x00080000
PLAYER_STATE2_20 = 1 << 20, // 0x00100000
PLAYER_STATE2_21 = 1 << 21, // 0x00200000
PLAYER_STATE2_22 = 1 << 22, // 0x00400000
PLAYER_STATE2_23 = 1 << 23, // 0x00800000
PLAYER_STATE2_24 = 1 << 24, // 0x01000000
PLAYER_STATE2_25 = 1 << 25, // 0x02000000
PLAYER_STATE2_26 = 1 << 26, // 0x04000000
PLAYER_STATE2_27 = 1 << 27, // 0x08000000
PLAYER_STATE2_28 = 1 << 28, // 0x10000000
PLAYER_STATE2_29 = 1 << 29, // 0x20000000
PLAYER_STATE2_30 = 1 << 30, // 0x40000000
PLAYER_STATE2_31 = 1 << 31, // 0x80000000
PLAYER_STATE2_14 = 1 << 14, // 0x00004000
PLAYER_STATE2_15 = 1 << 15, // 0x00008000
PLAYER_STATE2_16 = 1 << 16, // 0x00010000
PLAYER_STATE2_17 = 1 << 17, // 0x00020000
PLAYER_STATE2_CRAWL = 1 << 18, // 0x00040000
PLAYER_STATE2_19 = 1 << 19, // 0x00080000
PLAYER_STATE2_20 = 1 << 20, // 0x00100000
PLAYER_STATE2_21 = 1 << 21, // 0x00200000
PLAYER_STATE2_22 = 1 << 22, // 0x00400000
PLAYER_STATE2_23 = 1 << 23, // 0x00800000
PLAYER_STATE2_24 = 1 << 24, // 0x01000000
PLAYER_STATE2_25 = 1 << 25, // 0x02000000
PLAYER_STATE2_26 = 1 << 26, // 0x04000000
PLAYER_STATE2_27 = 1 << 27, // 0x08000000
PLAYER_STATE2_28 = 1 << 28, // 0x10000000
PLAYER_STATE2_29 = 1 << 29, // 0x20000000
PLAYER_STATE2_30 = 1 << 30, // 0x40000000
PLAYER_STATE2_31 = 1 << 31, // 0x80000000
};
static_assert((1 << 13) == 0x2000, "bah");

7
include/porting_defs.h
View File

@ -6,12 +6,9 @@
#define LITTLE_ENDIAN
#endif
#define SWAP16(data) \
( (((data) >> 8) & 0x00FF) | (((data) << 8) & 0xFF00) )
#define SWAP16(data) ((((data) >> 8) & 0x00FF) | (((data) << 8) & 0xFF00))
#define SWAP32(data) \
( (((data) >> 24) & 0x000000FF) | (((data) >> 8) & 0x0000FF00) | \
(((data) << 8) & 0x00FF0000) | (((data) << 24) & 0xFF000000) )
#define SWAP32(data) ((((data) >> 24) & 0x000000FF) | (((data) >> 8) & 0x0000FF00) | (((data) << 8) & 0x00FF0000) | (((data) << 24) & 0xFF000000))
#if UINTPTR_MAX == 0xffffffff
#define WORD_BITS 32

66
include/quake.h
View File

@ -3,43 +3,47 @@
#include "z64camera.h"
#include "z64math.h"
struct SubQuakeRequest14 {
/* 0x00 */ s16 unk_00;
/* 0x02 */ s16 unk_02;
/* 0x04 */ s16 unk_04;
struct SubQuakeRequest14
{
/* 0x00 */ s16 unk_00;
/* 0x02 */ s16 unk_02;
/* 0x04 */ s16 unk_04;
};
struct QuakeRequest {
/* 0x00 */ s16 randIdx;
/* 0x02 */ s16 countdownMax;
/* 0x04 */ Camera* cam;
/* 0x08 */ u32 callbackIdx;
/* 0x0C */ s16 y;
/* 0x0E */ s16 x;
/* 0x10 */ s16 zoom;
/* 0x12 */ s16 rotZ;
/* 0x14 */ SubQuakeRequest14 unk_14;
/* 0x1A */ s16 speed;
/* 0x1C */ s16 unk_1C;
/* 0x1E */ s16 countdown;
/* 0x20 */ s16 camPtrIdx;
struct QuakeRequest
{
/* 0x00 */ s16 randIdx;
/* 0x02 */ s16 countdownMax;
/* 0x04 */ Camera* cam;
/* 0x08 */ u32 callbackIdx;
/* 0x0C */ s16 y;
/* 0x0E */ s16 x;
/* 0x10 */ s16 zoom;
/* 0x12 */ s16 rotZ;
/* 0x14 */ SubQuakeRequest14 unk_14;
/* 0x1A */ s16 speed;
/* 0x1C */ s16 unk_1C;
/* 0x1E */ s16 countdown;
/* 0x20 */ s16 camPtrIdx;
}; // size = 0x24
struct ShakeInfo {
/* 0x00 */ Vec3f vec1;
/* 0x0C */ Vec3f vec2;
/* 0x18 */ s16 rotZ;
/* 0x1A */ s16 unk_1A;
/* 0x1C */ s16 zoom;
struct ShakeInfo
{
/* 0x00 */ Vec3f vec1;
/* 0x0C */ Vec3f vec2;
/* 0x18 */ s16 rotZ;
/* 0x1A */ s16 unk_1A;
/* 0x1C */ s16 zoom;
}; // size = 0x1E
struct QuakeCamCalc {
/* 0x00 */ Vec3f atOffset;
/* 0x0C */ Vec3f eyeOffset;
/* 0x18 */ s16 rotZ;
/* 0x1A */ s16 unk_1A;
/* 0x1C */ s16 zoom;
/* 0x20 */ f32 unk_20;
struct QuakeCamCalc
{
/* 0x00 */ Vec3f atOffset;
/* 0x0C */ Vec3f eyeOffset;
/* 0x18 */ s16 rotZ;
/* 0x1A */ s16 unk_1A;
/* 0x1C */ s16 zoom;
/* 0x20 */ f32 unk_20;
}; // size = 0x24
/*

3
include/redef_msgqueue.h
View File

@ -1,4 +1,3 @@
#undef osCreateMesgQueue
#include <thread>
#include <chrono>
#include <thread>

248
include/regs.h
View File

@ -3,11 +3,11 @@
#define REG_GROUPS 29 // number of REG groups, i.e. REG, SREG, OREG, etc.
#define REG_PAGES 6
#define REG_PER_PAGE 16
#define REG_PER_GROUP REG_PAGES * REG_PER_PAGE
#define REG_PER_GROUP REG_PAGES* REG_PER_PAGE
#define BASE_REG(n, r) gGameInfo->data[n * REG_PER_GROUP + r]
#define REG(r) BASE_REG(0, r)
#define REG(r) BASE_REG(0, r)
#define SREG(r) BASE_REG(1, r)
#define OREG(r) BASE_REG(2, r)
#define PREG(r) BASE_REG(3, r)
@ -37,128 +37,126 @@
#define kREG(r) BASE_REG(27, r)
#define bREG(r) BASE_REG(28, r)
#define R_ENV_AMBIENT_COLOR(i) REG(0 + i)
#define R_ENV_LIGHT1_COLOR(i) REG(3 + i)
#define R_ENV_LIGHT2_COLOR(i) REG(6 + i)
#define R_ENV_DISABLE_DBG REG(9)
#define R_ENV_FOG_COLOR(i) REG(10 + i)
#define R_ENV_FOG_FAR REG(13)
#define R_ENV_FOG_NEAR REG(14)
#define R_ENV_TIME_INCREMENT REG(15)
#define R_RUN_SPEED_LIMIT REG(45)
#define R_ENABLE_ARENA_DBG SREG(0)
#define R_UPDATE_RATE SREG(30)
#define R_ENABLE_AUDIO_DBG SREG(36)
#define R_FB_FILTER_TYPE SREG(80)
#define R_FB_FILTER_PRIM_COLOR(c) SREG(81 + c)
#define R_FB_FILTER_A SREG(84)
#define R_FB_FILTER_ENV_COLOR(c) SREG(85 + c)
#define R_ENABLE_FB_FILTER SREG(88)
#define R_PAUSE_MENU_MODE SREG(94)
#define R_CAM_MAX_PHI OREG(5)
#define R_CAM_DEFA_PHI_UPDRATE OREG(7)
#define R_DEFA_CAM_ANIM_TIME OREG(23)
#define R_CAM_MIN_PHI OREG(34)
#define R_CAM_MIN_PHI2 OREG(35)
#define R_AT_LERP_MIN OREG(41)
#define R_AT_LERP_SCALE OREG(42)
#define R_CAM_YOFFSET_NORM OREG(46)
#define R_CAM_FIXED3_FOV PREG(7)
#define R_DBG_CAM_UPDATE PREG(80)
#define R_DBG_REG_UPDATE PREG(82)
#define R_RELOAD_CAM_PARAMS QREG(0)
#define R_C_UP_ICON_X YREG(88)
#define R_C_UP_ICON_Y YREG(89)
#define R_MAGIC_FILL_COLOR(i) ZREG(0 + i)
#define R_C_BTN_COLOR(i) ZREG(39 + i)
#define R_B_BTN_COLOR(i) ZREG(43 + i)
#define R_START_LABEL_DD(i) ZREG(48 + i)
#define R_START_LABEL_Y(i) ZREG(51 + i)
#define R_START_LABEL_X(i) ZREG(54 + i)
#define R_C_UP_BTN_X ZREG(62)
#define R_C_UP_BTN_Y ZREG(63)
#define R_START_BTN_X ZREG(68)
#define R_START_BTN_Y ZREG(69)
#define R_ITEM_BTN_X(i) ZREG(70 + i)
#define R_ITEM_BTN_Y(i) ZREG(74 + i)
#define R_ITEM_BTN_DD(i) ZREG(78 + i)
#define R_ITEM_ICON_X(i) ZREG(82 + i)
#define R_ITEM_ICON_Y(i) ZREG(86 + i)
#define R_ITEM_ICON_DD(i) ZREG(90 + i)
#define R_ENV_WIND_DIR(i) CREG(16 + i)
#define R_ENV_WIND_SPEED CREG(19)
#define R_A_BTN_Y XREG(16)
#define R_A_BTN_X XREG(17)
#define R_A_ICON_Y XREG(19)
#define R_A_ICON_X XREG(20)
#define R_A_BTN_COLOR(i) XREG(22 + i)
#define R_MAGIC_BAR_SMALL_Y XREG(48)
#define R_MAGIC_BAR_X XREG(49)
#define R_MAGIC_BAR_LARGE_Y XREG(50)
#define R_MAGIC_FILL_X XREG(51)
#define R_ENV_LIGHT1_DIR(i) cREG(3 + i)
#define R_ENV_LIGHT2_DIR(i) cREG(6 + i)
#define R_B_LABEL_DD WREG(0)
#define R_OW_MINIMAP_X WREG(29)
#define R_OW_MINIMAP_Y WREG(30)
#define R_MINIMAP_DISABLED WREG(31)
#define R_B_LABEL_X(i) WREG(40 + i)
#define R_B_LABEL_Y(i) WREG(43 + i)
#define R_DGN_MINIMAP_X WREG(68)
#define R_DGN_MINIMAP_Y WREG(69)
#define R_MAP_INDEX VREG(11)
#define R_MAP_TEX_INDEX_BASE VREG(12)
#define R_MAP_TEX_INDEX VREG(13)
#define R_COMPASS_SCALE_X VREG(14)
#define R_COMPASS_SCALE_Y VREG(15)
#define R_COMPASS_OFFSET_X VREG(16)
#define R_COMPASS_OFFSET_Y VREG(17)
#define R_MINIMAP_COLOR(i) VREG(18 + i)
#define R_ITEM_AMMO_X(i) VREG(64 + i)
#define R_ITEM_AMMO_Y(i) VREG(68 + i)
#define R_ITEM_ICON_WIDTH(i) VREG(76 + i)
#define R_ITEM_BTN_WIDTH(i) VREG(80 + i)
#define R_DISABLE_INPUT_DISPLAY HREG(47)
#define R_EN_GOROIWA_SPEED mREG(12)
#define R_NAVI_MSG_REGION_ALPHA nREG(87)
#define R_TEXT_DROP_SHADOW_OFFSET XREG(60)
#define R_TEXTBOX_X_TARGET XREG(72)
#define R_TEXTBOX_Y_TARGET XREG(73)
#define R_TEXTBOX_TEXWIDTH YREG(16)
#define R_TEXTBOX_TEXHEIGHT YREG(17)
#define R_TEXTBOX_WIDTH YREG(22)
#define R_TEXTBOX_HEIGHT YREG(23)
#define R_MESSAGE_DEBUGGER_SELECT YREG(78)
#define R_MESSAGE_DEBUGGER_TEXTID YREG(79)
#define R_TEXT_LINE_SPACING XREG(56)
#define R_TEXT_CHAR_SCALE XREG(57)
#define R_TEXTBOX_ICON_XPOS YREG(71)
#define R_TEXTBOX_ICON_YPOS YREG(72)
#define R_TEXTBOX_ICON_SIZE YREG(75)
#define R_TEXTBOX_X VREG(0)
#define R_TEXTBOX_Y VREG(1)
#define R_TEXTBOX_END_XPOS XREG(64)
#define R_TEXTBOX_END_YPOS XREG(65)
#define R_TEXTBOX_WIDTH_TARGET XREG(74)
#define R_TEXTBOX_HEIGHT_TARGET XREG(75)
#define R_TEXTBOX_TEXWIDTH_TARGET XREG(76)
#define R_TEXTBOX_TEXHEIGHT_TARGET XREG(77)
#define R_TEXT_ADJUST_COLOR_1_R VREG(33)
#define R_TEXT_ADJUST_COLOR_1_G VREG(34)
#define R_TEXT_ADJUST_COLOR_1_B VREG(35)
#define R_TEXT_ADJUST_COLOR_2_R VREG(36)
#define R_TEXT_ADJUST_COLOR_2_G VREG(37)
#define R_TEXT_ADJUST_COLOR_2_B VREG(38)
#define R_TEXT_CHOICE_XPOS XREG(66)
#define R_TEXT_CHOICE_YPOS(choice) XREG(67 + (choice))
#define R_TEXT_INIT_XPOS XREG(54)
#define R_TEXT_INIT_YPOS XREG(55)
#define R_TEXTBOX_BG_YPOS XREG(61)
#define R_TEXTBOX_CLEF_XPOS VREG(7)
#define R_TEXTBOX_CLEF_YPOS VREG(8)
#define R_OCARINA_NOTES_XPOS VREG(28)
#define R_OCARINA_NOTES_YPOS(note) VREG(45 + (note))
#define R_ENV_AMBIENT_COLOR(i) REG(0 + i)
#define R_ENV_LIGHT1_COLOR(i) REG(3 + i)
#define R_ENV_LIGHT2_COLOR(i) REG(6 + i)
#define R_ENV_DISABLE_DBG REG(9)
#define R_ENV_FOG_COLOR(i) REG(10 + i)
#define R_ENV_FOG_FAR REG(13)
#define R_ENV_FOG_NEAR REG(14)
#define R_ENV_TIME_INCREMENT REG(15)
#define R_RUN_SPEED_LIMIT REG(45)
#define R_ENABLE_ARENA_DBG SREG(0)
#define R_UPDATE_RATE SREG(30)
#define R_ENABLE_AUDIO_DBG SREG(36)
#define R_FB_FILTER_TYPE SREG(80)
#define R_FB_FILTER_PRIM_COLOR(c) SREG(81 + c)
#define R_FB_FILTER_A SREG(84)
#define R_FB_FILTER_ENV_COLOR(c) SREG(85 + c)
#define R_ENABLE_FB_FILTER SREG(88)
#define R_PAUSE_MENU_MODE SREG(94)
#define R_CAM_MAX_PHI OREG(5)
#define R_CAM_DEFA_PHI_UPDRATE OREG(7)
#define R_DEFA_CAM_ANIM_TIME OREG(23)
#define R_CAM_MIN_PHI OREG(34)
#define R_CAM_MIN_PHI2 OREG(35)
#define R_AT_LERP_MIN OREG(41)
#define R_AT_LERP_SCALE OREG(42)
#define R_CAM_YOFFSET_NORM OREG(46)
#define R_CAM_FIXED3_FOV PREG(7)
#define R_DBG_CAM_UPDATE PREG(80)
#define R_DBG_REG_UPDATE PREG(82)
#define R_RELOAD_CAM_PARAMS QREG(0)
#define R_C_UP_ICON_X YREG(88)
#define R_C_UP_ICON_Y YREG(89)
#define R_MAGIC_FILL_COLOR(i) ZREG(0 + i)
#define R_C_BTN_COLOR(i) ZREG(39 + i)
#define R_B_BTN_COLOR(i) ZREG(43 + i)
#define R_START_LABEL_DD(i) ZREG(48 + i)
#define R_START_LABEL_Y(i) ZREG(51 + i)
#define R_START_LABEL_X(i) ZREG(54 + i)
#define R_C_UP_BTN_X ZREG(62)
#define R_C_UP_BTN_Y ZREG(63)
#define R_START_BTN_X ZREG(68)
#define R_START_BTN_Y ZREG(69)
#define R_ITEM_BTN_X(i) ZREG(70 + i)
#define R_ITEM_BTN_Y(i) ZREG(74 + i)
#define R_ITEM_BTN_DD(i) ZREG(78 + i)
#define R_ITEM_ICON_X(i) ZREG(82 + i)
#define R_ITEM_ICON_Y(i) ZREG(86 + i)
#define R_ITEM_ICON_DD(i) ZREG(90 + i)
#define R_ENV_WIND_DIR(i) CREG(16 + i)
#define R_ENV_WIND_SPEED CREG(19)
#define R_A_BTN_Y XREG(16)
#define R_A_BTN_X XREG(17)
#define R_A_ICON_Y XREG(19)
#define R_A_ICON_X XREG(20)
#define R_A_BTN_COLOR(i) XREG(22 + i)
#define R_MAGIC_BAR_SMALL_Y XREG(48)
#define R_MAGIC_BAR_X XREG(49)
#define R_MAGIC_BAR_LARGE_Y XREG(50)
#define R_MAGIC_FILL_X XREG(51)
#define R_ENV_LIGHT1_DIR(i) cREG(3 + i)
#define R_ENV_LIGHT2_DIR(i) cREG(6 + i)
#define R_B_LABEL_DD WREG(0)
#define R_OW_MINIMAP_X WREG(29)
#define R_OW_MINIMAP_Y WREG(30)
#define R_MINIMAP_DISABLED WREG(31)
#define R_B_LABEL_X(i) WREG(40 + i)
#define R_B_LABEL_Y(i) WREG(43 + i)
#define R_DGN_MINIMAP_X WREG(68)
#define R_DGN_MINIMAP_Y WREG(69)
#define R_MAP_INDEX VREG(11)
#define R_MAP_TEX_INDEX_BASE VREG(12)
#define R_MAP_TEX_INDEX VREG(13)
#define R_COMPASS_SCALE_X VREG(14)
#define R_COMPASS_SCALE_Y VREG(15)
#define R_COMPASS_OFFSET_X VREG(16)
#define R_COMPASS_OFFSET_Y VREG(17)
#define R_MINIMAP_COLOR(i) VREG(18 + i)
#define R_ITEM_AMMO_X(i) VREG(64 + i)
#define R_ITEM_AMMO_Y(i) VREG(68 + i)
#define R_ITEM_ICON_WIDTH(i) VREG(76 + i)
#define R_ITEM_BTN_WIDTH(i) VREG(80 + i)
#define R_DISABLE_INPUT_DISPLAY HREG(47)
#define R_EN_GOROIWA_SPEED mREG(12)
#define R_NAVI_MSG_REGION_ALPHA nREG(87)
#define R_TEXT_DROP_SHADOW_OFFSET XREG(60)
#define R_TEXTBOX_X_TARGET XREG(72)
#define R_TEXTBOX_Y_TARGET XREG(73)
#define R_TEXTBOX_TEXWIDTH YREG(16)
#define R_TEXTBOX_TEXHEIGHT YREG(17)
#define R_TEXTBOX_WIDTH YREG(22)
#define R_TEXTBOX_HEIGHT YREG(23)
#define R_MESSAGE_DEBUGGER_SELECT YREG(78)
#define R_MESSAGE_DEBUGGER_TEXTID YREG(79)
#define R_TEXT_LINE_SPACING XREG(56)
#define R_TEXT_CHAR_SCALE XREG(57)
#define R_TEXTBOX_ICON_XPOS YREG(71)
#define R_TEXTBOX_ICON_YPOS YREG(72)
#define R_TEXTBOX_ICON_SIZE YREG(75)
#define R_TEXTBOX_X VREG(0)
#define R_TEXTBOX_Y VREG(1)
#define R_TEXTBOX_END_XPOS XREG(64)
#define R_TEXTBOX_END_YPOS XREG(65)
#define R_TEXTBOX_WIDTH_TARGET XREG(74)
#define R_TEXTBOX_HEIGHT_TARGET XREG(75)
#define R_TEXTBOX_TEXWIDTH_TARGET XREG(76)
#define R_TEXTBOX_TEXHEIGHT_TARGET XREG(77)
#define R_TEXT_ADJUST_COLOR_1_R VREG(33)
#define R_TEXT_ADJUST_COLOR_1_G VREG(34)
#define R_TEXT_ADJUST_COLOR_1_B VREG(35)
#define R_TEXT_ADJUST_COLOR_2_R VREG(36)
#define R_TEXT_ADJUST_COLOR_2_G VREG(37)
#define R_TEXT_ADJUST_COLOR_2_B VREG(38)
#define R_TEXT_CHOICE_XPOS XREG(66)
#define R_TEXT_CHOICE_YPOS(choice) XREG(67 + (choice))
#define R_TEXT_INIT_XPOS XREG(54)
#define R_TEXT_INIT_YPOS XREG(55)
#define R_TEXTBOX_BG_YPOS XREG(61)
#define R_TEXTBOX_CLEF_XPOS VREG(7)
#define R_TEXTBOX_CLEF_YPOS VREG(8)
#define R_OCARINA_NOTES_XPOS VREG(28)
#define R_OCARINA_NOTES_YPOS(note) VREG(45 + (note))
#define R_OCARINA_NOTES_XPOS_OFFSET VREG(29)
#define R_OCARINA_NOTES_YPOS_OFFSET VREG(51)

1
include/rsp.h
View File

@ -8,4 +8,3 @@ extern u8 D_80157580[0x420];
extern u8 D_80155F50[0x1630];
extern u8 D_800093F0[0x20];
extern u64 D_801120C0[0x1F6];

24
include/segment_symbols.h
View File

@ -3,21 +3,21 @@
#include "z64.h"
#define DECLARE_SEGMENT(name) \
static u8 _##name##SegmentStart[1]; \
static u8 _##name##SegmentEnd[1];
#define DECLARE_SEGMENT(name) \
static u8 _##name##SegmentStart[1]; \
static u8 _##name##SegmentEnd[1];
#define DECLARE_ROM_SEGMENT(name) \
static u8 _##name##SegmentRomStart[1]; \
static u8 _##name##SegmentRomEnd[1];
#define DECLARE_ROM_SEGMENT(name) \
static u8 _##name##SegmentRomStart[1]; \
static u8 _##name##SegmentRomEnd[1];
#define DECLARE_BSS_SEGMENT(name) \
static u8 _##name##SegmentBssStart[1]; \
static u8 _##name##SegmentBssEnd[1];
#define DECLARE_BSS_SEGMENT(name) \
static u8 _##name##SegmentBssStart[1]; \
static u8 _##name##SegmentBssEnd[1];
#define DECLARE_OVERLAY_SEGMENT(name) \
DECLARE_SEGMENT(ovl_##name) \
DECLARE_ROM_SEGMENT(ovl_##name)
#define DECLARE_OVERLAY_SEGMENT(name) \
DECLARE_SEGMENT(ovl_##name) \
DECLARE_ROM_SEGMENT(ovl_##name)
DECLARE_SEGMENT(boot)
DECLARE_ROM_SEGMENT(boot)

176
include/sequence.h
View File

@ -3,10 +3,10 @@
#define NA_BGM_STOP 0x100000FF
#define NA_BGM_GENERAL_SFX 0x0 // General Sound Effects
#define NA_BGM_GENERAL_SFX 0x0 // General Sound Effects
#define NA_BGM_NATURE_AMBIENCE 0x1 // Environmental nature background sounds
#define NA_BGM_FIELD_LOGIC 0x2 // Hyrule Field
#define NA_BGM_FIELD_INIT 0x3 // Hyrule Field Initial Segment From Loading Area
#define NA_BGM_FIELD_LOGIC 0x2 // Hyrule Field
#define NA_BGM_FIELD_INIT 0x3 // Hyrule Field Initial Segment From Loading Area
#define NA_BGM_FIELD_DEFAULT_1 0x4 // Hyrule Field Moving Segment 1
#define NA_BGM_FIELD_DEFAULT_2 0x5 // Hyrule Field Moving Segment 2
#define NA_BGM_FIELD_DEFAULT_3 0x6 // Hyrule Field Moving Segment 3
@ -27,128 +27,130 @@
#define NA_BGM_FIELD_STILL_2 0x15 // Hyrule Field Standing Still Segment 2
#define NA_BGM_FIELD_STILL_3 0x16 // Hyrule Field Standing Still Segment 3
#define NA_BGM_FIELD_STILL_4 0x17 // Hyrule Field Standing Still Segment 4
#define NA_BGM_DUNGEON 0x18 // Dodongo's Cavern
#define NA_BGM_DUNGEON 0x18 // Dodongo's Cavern
#define NA_BGM_KAKARIKO_ADULT 0x19 // Kakariko Village (Adult)
#define NA_BGM_ENEMY 0x1A // Battle
#define NA_BGM_BOSS 0x1B // Boss Battle "NA_BGM_BOSS00"
#define NA_BGM_ENEMY 0x1A // Battle
#define NA_BGM_BOSS 0x1B // Boss Battle "NA_BGM_BOSS00"
#define NA_BGM_INSIDE_DEKU_TREE 0x1C // Inside the Deku Tree "NA_BGM_FAIRY_DUNGEON"
#define NA_BGM_MARKET 0x1D // Market
#define NA_BGM_TITLE 0x1E // Title Theme
#define NA_BGM_LINK_HOUSE 0x1F // House
#define NA_BGM_GAME_OVER 0x20 // Game Over
#define NA_BGM_BOSS_CLEAR 0x21 // Boss Clear
#define NA_BGM_ITEM_GET 0x22 // Obtain Item
#define NA_BGM_MARKET 0x1D // Market
#define NA_BGM_TITLE 0x1E // Title Theme
#define NA_BGM_LINK_HOUSE 0x1F // House
#define NA_BGM_GAME_OVER 0x20 // Game Over
#define NA_BGM_BOSS_CLEAR 0x21 // Boss Clear
#define NA_BGM_ITEM_GET 0x22 // Obtain Item
#define NA_BGM_OPENING_GANON 0x23 // Enter Ganondorf
#define NA_BGM_HEART_GET 0x24 // Obtain Heart Container
#define NA_BGM_OCA_LIGHT 0x25 // Prelude of Light
#define NA_BGM_JABU_JABU 0x26 // Inside Jabu-Jabu's Belly "NA_BGM_BUYO_DUNGEON"
#define NA_BGM_HEART_GET 0x24 // Obtain Heart Container
#define NA_BGM_OCA_LIGHT 0x25 // Prelude of Light
#define NA_BGM_JABU_JABU 0x26 // Inside Jabu-Jabu's Belly "NA_BGM_BUYO_DUNGEON"
#define NA_BGM_KAKARIKO_KID 0x27 // Kakariko Village (Child)
#define NA_BGM_GREAT_FAIRY 0x28 // Great Fairy's Fountain "NA_BGM_GODESS"
#define NA_BGM_ZELDA_THEME 0x29 // Zelda's Theme "NA_BGM_HIME"
#define NA_BGM_FIRE_TEMPLE 0x2A // Fire Temple "NA_BGM_FIRE_DUNGEON"
#define NA_BGM_GREAT_FAIRY 0x28 // Great Fairy's Fountain "NA_BGM_GODESS"
#define NA_BGM_ZELDA_THEME 0x29 // Zelda's Theme "NA_BGM_HIME"
#define NA_BGM_FIRE_TEMPLE 0x2A // Fire Temple "NA_BGM_FIRE_DUNGEON"
#define NA_BGM_OPEN_TRE_BOX 0x2B // Open Treasure Chest
#define NA_BGM_FOREST_TEMPLE 0x2C // Forest Temple "NA_BGM_FORST_DUNGEON"
#define NA_BGM_COURTYARD 0x2D // Hyrule Castle Courtyard "NA_BGM_HIRAL_GARDEN"
#define NA_BGM_GANON_TOWER 0x2E // Ganondorf's Theme
#define NA_BGM_LONLON 0x2F // Lon Lon Ranch "NA_BGM_RONRON"
#define NA_BGM_GORON_CITY 0x30 // Goron City "NA_BGM_GORON"
#define NA_BGM_COURTYARD 0x2D // Hyrule Castle Courtyard "NA_BGM_HIRAL_GARDEN"
#define NA_BGM_GANON_TOWER 0x2E // Ganondorf's Theme
#define NA_BGM_LONLON 0x2F // Lon Lon Ranch "NA_BGM_RONRON"
#define NA_BGM_GORON_CITY 0x30 // Goron City "NA_BGM_GORON"
#define NA_BGM_FIELD_MORNING 0x31 // Hyrule Field Morning Theme
#define NA_BGM_SPIRITUAL_STONE 0x32 // Spiritual Stone Get "NA_BGM_SPIRIT_STONE"
#define NA_BGM_OCA_BOLERO 0x33 // Bolero of Fire "NA_BGM_OCA_FLAME"
#define NA_BGM_OCA_MINUET 0x34 // Minuet of Forest "NA_BGM_OCA_WIND"
#define NA_BGM_OCA_BOLERO 0x33 // Bolero of Fire "NA_BGM_OCA_FLAME"
#define NA_BGM_OCA_MINUET 0x34 // Minuet of Forest "NA_BGM_OCA_WIND"
#define NA_BGM_OCA_SERENADE 0x35 // Serenade of Water "NA_BGM_OCA_WATER"
#define NA_BGM_OCA_REQUIEM 0x36 // Requiem of Spirit "NA_BGM_OCA_SOUL"
#define NA_BGM_OCA_REQUIEM 0x36 // Requiem of Spirit "NA_BGM_OCA_SOUL"
#define NA_BGM_OCA_NOCTURNE 0x37 // Nocturne of Shadow "NA_BGM_OCA_DARKNESS"
#define NA_BGM_MINI_BOSS 0x38 // Mini-Boss Battle "NA_BGM_MIDDLE_BOSS"
#define NA_BGM_MINI_BOSS 0x38 // Mini-Boss Battle "NA_BGM_MIDDLE_BOSS"
#define NA_BGM_SMALL_ITEM_GET 0x39 // Obtain Small Item "NA_BGM_S_ITEM_GET"
#define NA_BGM_TEMPLE_OF_TIME 0x3A // Temple of Time "NA_BGM_SHRINE_OF_TIME"
#define NA_BGM_EVENT_CLEAR 0x3B // Escape from Lon Lon Ranch
#define NA_BGM_KOKIRI 0x3C // Kokiri Forest
#define NA_BGM_EVENT_CLEAR 0x3B // Escape from Lon Lon Ranch
#define NA_BGM_KOKIRI 0x3C // Kokiri Forest
#define NA_BGM_OCA_FAIRY_GET 0x3D // Obtain Fairy Ocarina "NA_BGM_OCA_YOUSEI"
#define NA_BGM_SARIA_THEME 0x3E // Lost Woods "NA_BGM_MAYOIMORI"
#define NA_BGM_SARIA_THEME 0x3E // Lost Woods "NA_BGM_MAYOIMORI"
#define NA_BGM_SPIRIT_TEMPLE 0x3F // Spirit Temple "NA_BGM_SOUL_DUNGEON"
#define NA_BGM_HORSE 0x40 // Horse Race
#define NA_BGM_HORSE_GOAL 0x41 // Horse Race Goal
#define NA_BGM_INGO 0x42 // Ingo's Theme
#define NA_BGM_HORSE 0x40 // Horse Race
#define NA_BGM_HORSE_GOAL 0x41 // Horse Race Goal
#define NA_BGM_INGO 0x42 // Ingo's Theme
#define NA_BGM_MEDALLION_GET 0x43 // Obtain Medallion "NA_BGM_MEDAL_GET"
#define NA_BGM_OCA_SARIA 0x44 // Ocarina Saria's Song
#define NA_BGM_OCA_EPONA 0x45 // Ocarina Epona's Song
#define NA_BGM_OCA_ZELDA 0x46 // Ocarina Zelda's Lullaby
#define NA_BGM_OCA_SUNS 0x47 // Ocarina Sun's Song "NA_BGM_OCA_SUNMOON"
#define NA_BGM_OCA_TIME 0x48 // Ocarina Song of Time
#define NA_BGM_OCA_STORM 0x49 // Ocarina Song of Storms
#define NA_BGM_OCA_SARIA 0x44 // Ocarina Saria's Song
#define NA_BGM_OCA_EPONA 0x45 // Ocarina Epona's Song
#define NA_BGM_OCA_ZELDA 0x46 // Ocarina Zelda's Lullaby
#define NA_BGM_OCA_SUNS 0x47 // Ocarina Sun's Song "NA_BGM_OCA_SUNMOON"
#define NA_BGM_OCA_TIME 0x48 // Ocarina Song of Time
#define NA_BGM_OCA_STORM 0x49 // Ocarina Song of Storms
#define NA_BGM_NAVI_OPENING 0x4A // Fairy Flying "NA_BGM_NAVI"
#define NA_BGM_DEKU_TREE_CS 0x4B // Deku Tree "NA_BGM_DEKUNOKI"
#define NA_BGM_WINDMILL 0x4C // Windmill Hut "NA_BGM_FUSHA"
#define NA_BGM_HYRULE_CS 0x4D // Legend of Hyrule "NA_BGM_HIRAL_DEMO"
#define NA_BGM_MINI_GAME 0x4E // Shooting Gallery
#define NA_BGM_SHEIK 0x4F // Sheik's Theme "NA_BGM_SEAK"
#define NA_BGM_ZORA_DOMAIN 0x50 // Zora's Domain "NA_BGM_ZORA"
#define NA_BGM_APPEAR 0x51 // Enter Zelda
#define NA_BGM_ADULT_LINK 0x52 // Goodbye to Zelda
#define NA_BGM_WINDMILL 0x4C // Windmill Hut "NA_BGM_FUSHA"
#define NA_BGM_HYRULE_CS 0x4D // Legend of Hyrule "NA_BGM_HIRAL_DEMO"
#define NA_BGM_MINI_GAME 0x4E // Shooting Gallery
#define NA_BGM_SHEIK 0x4F // Sheik's Theme "NA_BGM_SEAK"
#define NA_BGM_ZORA_DOMAIN 0x50 // Zora's Domain "NA_BGM_ZORA"
#define NA_BGM_APPEAR 0x51 // Enter Zelda
#define NA_BGM_ADULT_LINK 0x52 // Goodbye to Zelda
#define NA_BGM_MASTER_SWORD 0x53 // Master Sword
#define NA_BGM_INTRO_GANON 0x54
#define NA_BGM_SHOP 0x55 // Shop
#define NA_BGM_SHOP 0x55 // Shop
#define NA_BGM_CHAMBER_OF_SAGES 0x56 // Chamber of the Sages "NA_BGM_KENJA"
#define NA_BGM_FILE_SELECT 0x57 // File Select
#define NA_BGM_ICE_CAVERN 0x58 // Ice Cavern "NA_BGM_ICE_DUNGEON"
#define NA_BGM_FILE_SELECT 0x57 // File Select
#define NA_BGM_ICE_CAVERN 0x58 // Ice Cavern "NA_BGM_ICE_DUNGEON"
#define NA_BGM_DOOR_OF_TIME 0x59 // Open Door of Temple of Time "NA_BGM_GATE_OPEN"
#define NA_BGM_OWL 0x5A // Kaepora Gaebora's Theme
#define NA_BGM_OWL 0x5A // Kaepora Gaebora's Theme
#define NA_BGM_SHADOW_TEMPLE 0x5B // Shadow Temple "NA_BGM_DARKNESS_DUNGEON"
#define NA_BGM_WATER_TEMPLE 0x5C // Water Temple "NA_BGM_AQUA_DUNGEON"
#define NA_BGM_BRIDGE_TO_GANONS 0x5D // Ganon's Castle Bridge "NA_BGM_BRIDGE"
#define NA_BGM_OCARINA_OF_TIME 0x5E // Ocarina of Time "NA_BGM_SARIA"
#define NA_BGM_GERUDO_VALLEY 0x5F // Gerudo Valley "NA_BGM_GERUDO"
#define NA_BGM_POTION_SHOP 0x60 // Potion Shop "NA_BGM_DRUGSTORE"
#define NA_BGM_POTION_SHOP 0x60 // Potion Shop "NA_BGM_DRUGSTORE"
#define NA_BGM_KOTAKE_KOUME 0x61 // Kotake & Koume's Theme
#define NA_BGM_ESCAPE 0x62 // Escape from Ganon's Castle
#define NA_BGM_UNDERGROUND 0x63 // Ganon's Castle Under Ground
#define NA_BGM_ESCAPE 0x62 // Escape from Ganon's Castle
#define NA_BGM_UNDERGROUND 0x63 // Ganon's Castle Under Ground
#define NA_BGM_GANONDORF_BOSS 0x64 // Ganondorf Battle
#define NA_BGM_GANON_BOSS 0x65 // Ganon Battle
#define NA_BGM_END_DEMO 0x66 // Seal of Six Sages
#define NA_BGM_STAFF_1 0x67 // End Credits I
#define NA_BGM_STAFF_2 0x68 // End Credits II
#define NA_BGM_STAFF_3 0x69 // End Credits III
#define NA_BGM_STAFF_4 0x6A // End Credits IV
#define NA_BGM_FIRE_BOSS 0x6B // King Dodongo & Volvagia Boss Battle "NA_BGM_BOSS01"
#define NA_BGM_MINI_GAME_2 0x6C // Mini-Game
#define NA_BGM_VARIOUS_SFX 0x6D // A small collection of various sound effects
#define NA_BGM_NO_MUSIC 0x7F // No bgm music is played
#define NA_BGM_GANON_BOSS 0x65 // Ganon Battle
#define NA_BGM_END_DEMO 0x66 // Seal of Six Sages
#define NA_BGM_STAFF_1 0x67 // End Credits I
#define NA_BGM_STAFF_2 0x68 // End Credits II
#define NA_BGM_STAFF_3 0x69 // End Credits III
#define NA_BGM_STAFF_4 0x6A // End Credits IV
#define NA_BGM_FIRE_BOSS 0x6B // King Dodongo & Volvagia Boss Battle "NA_BGM_BOSS01"
#define NA_BGM_MINI_GAME_2 0x6C // Mini-Game
#define NA_BGM_VARIOUS_SFX 0x6D // A small collection of various sound effects
#define NA_BGM_NO_MUSIC 0x7F // No bgm music is played
#define NA_BGM_NATURE_SFX_RAIN 0x80 // Related to rain
#define NA_BGM_DISABLED 0xFFFF
enum SequencePlayerId {
/* 0 */ SEQ_PLAYER_BGM_MAIN,
/* 1 */ SEQ_PLAYER_FANFARE,
/* 2 */ SEQ_PLAYER_SFX,
/* 3 */ SEQ_PLAYER_BGM_SUB
enum SequencePlayerId
{
/* 0 */ SEQ_PLAYER_BGM_MAIN,
/* 1 */ SEQ_PLAYER_FANFARE,
/* 2 */ SEQ_PLAYER_SFX,
/* 3 */ SEQ_PLAYER_BGM_SUB
};
enum SequenceMode {
/* 0 */ SEQ_MODE_DEFAULT,
/* 1 */ SEQ_MODE_ENEMY,
/* 2 */ SEQ_MODE_STILL, // Not moving or first-person view
/* 3 */ SEQ_MODE_IGNORE
enum SequenceMode
{
/* 0 */ SEQ_MODE_DEFAULT,
/* 1 */ SEQ_MODE_ENEMY,
/* 2 */ SEQ_MODE_STILL, // Not moving or first-person view
/* 3 */ SEQ_MODE_IGNORE
};
enum
{
AUDIO_CMD_SEQUENCE_PLAY = 0,
AUDIO_CMD_DISABLE_PLAYER = 1,
AUDIO_CMD_SEQUENCE_QUEUE = 2,
AUDIO_CMD_SEQUENCE_STOP = 3,
AUDIO_CMD_SEQUENCE_TRANS_VOLUME = 4,
AUDIO_CMD_SEQUENCE_PLAY = 0,
AUDIO_CMD_DISABLE_PLAYER = 1,
AUDIO_CMD_SEQUENCE_QUEUE = 2,
AUDIO_CMD_SEQUENCE_STOP = 3,
AUDIO_CMD_SEQUENCE_TRANS_VOLUME = 4,
AUDIO_CMD_SEQUENCE_TRANS_FREQ_SCALE_ALL = 5,
AUDIO_CMD_SEQUENCE_TRANS_FREQ_SCALE = 0x0D,
AUDIO_CMD_SEQUENCE_TRANS_VOL_SCALE = 0x06,
AUDIO_CMD_SET_IO_PORT_GLOBAL = 0x07,
AUDIO_CMD_SET_IO_PORT_MASKED = 0x08,
AUDIO_CMD_SET_IO_PORT_MASK = 0x09,
AUDIO_CMD_SET_CHANNEL_STOP_MASK = 0x0A,
AUDIO_CMD_UPDATE_TEMPO = 0x0B,
AUDIO_CMD_SEQUENCE_START_WITH_SETUP = 0x0C,
AUDIO_CMD_0E = 0x0E,
AUDIO_CMD_CHANGE_SPEC = 0x0F
AUDIO_CMD_SEQUENCE_TRANS_FREQ_SCALE = 0x0D,
AUDIO_CMD_SEQUENCE_TRANS_VOL_SCALE = 0x06,
AUDIO_CMD_SET_IO_PORT_GLOBAL = 0x07,
AUDIO_CMD_SET_IO_PORT_MASKED = 0x08,
AUDIO_CMD_SET_IO_PORT_MASK = 0x09,
AUDIO_CMD_SET_CHANNEL_STOP_MASK = 0x0A,
AUDIO_CMD_UPDATE_TEMPO = 0x0B,
AUDIO_CMD_SEQUENCE_START_WITH_SETUP = 0x0C,
AUDIO_CMD_0E = 0x0E,
AUDIO_CMD_CHANGE_SPEC = 0x0F
};
#endif

1
include/shrink_window.h
View File

@ -7,4 +7,3 @@ u32 ShrinkWindow_GetCurrentVal(void);
void ShrinkWindow_Init(void);
void ShrinkWindow_Destroy(void);
void ShrinkWindow_Update(s32 updateRate);

42
include/speedmeter.h
View File

@ -1,29 +1,32 @@
#pragma once
#include "ultra64/types.h"
#include "ultra64/time.h"
#include "ultra64/types.h"
struct SpeedMeter {
/* 0x00 */ char unk_00[0x18];
/* 0x18 */ s32 unk_18;
/* 0x1C */ s32 y;
struct SpeedMeter
{
/* 0x00 */ char unk_00[0x18];
/* 0x18 */ s32 unk_18;
/* 0x1C */ s32 y;
}; // size = 0x20
struct SpeedMeterAllocEntry {
/* 0x00 */ s32 maxval;
/* 0x04 */ s32 val;
/* 0x08 */ u16 backColor;
/* 0x0A */ u16 foreColor;
/* 0x0C */ s32 ulx;
/* 0x10 */ s32 lrx;
/* 0x14 */ s32 uly;
/* 0x18 */ s32 lry;
struct SpeedMeterAllocEntry
{
/* 0x00 */ s32 maxval;
/* 0x04 */ s32 val;
/* 0x08 */ u16 backColor;
/* 0x0A */ u16 foreColor;
/* 0x0C */ s32 ulx;
/* 0x10 */ s32 lrx;
/* 0x14 */ s32 uly;
/* 0x18 */ s32 lry;
}; // size = 0x1C
struct SpeedMeterTimeEntry {
/* 0x00 */ volatile OSTime* time;
/* 0x04 */ u8 x;
/* 0x05 */ u8 y;
/* 0x06 */ u16 color;
struct SpeedMeterTimeEntry
{
/* 0x00 */ volatile OSTime* time;
/* 0x04 */ u8 x;
/* 0x05 */ u8 y;
/* 0x06 */ u16 color;
}; // size = 0x08
extern volatile OSTime D_8016A520;
@ -38,4 +41,3 @@ extern volatile OSTime gRSPAudioTotalTime;
extern volatile OSTime gRSPGFXTotalTime;
extern volatile OSTime gRSPOtherTotalTime;
extern volatile OSTime gRDPTotalTime;

2
include/state.h
View File

@ -8,4 +8,4 @@ namespace oot
bool center_camera = false;
};
extern State state;
}
} // namespace oot

1
include/title_setup.h
View File

@ -1,4 +1,5 @@
#pragma once
struct GameState;
void TitleSetup_Init(GameState* gameState);
void TitleSetup_Destroy(GameState* gameState);

26
include/ultra64.h
View File

@ -4,29 +4,29 @@
#include "ultra64/types.h"
#include "unk.h"
#include "math.h"
#include "stdarg.h"
#include "stdbool.h"
#include "stddef.h"
#include "stdlib.h"
#include "math.h"
#include "ultra64/controller.h"
#include "ultra64/convert.h"
#include "ultra64/exception.h"
#include "ultra64/gu.h"
#include "ultra64/mbi.h"
#include "ultra64/message.h"
#include "ultra64/motor.h"
#include "ultra64/pfs.h"
#include "ultra64/pi.h"
#include "ultra64/printf.h"
#include "ultra64/r4300.h"
#include "ultra64/rcp.h"
#include "ultra64/rdp.h"
#include "ultra64/rsp.h"
#include "ultra64/thread.h"
#include "ultra64/convert.h"
#include "ultra64/time.h"
#include "ultra64/message.h"
#include "ultra64/sptask.h"
#include "ultra64/gu.h"
#include "ultra64/thread.h"
#include "ultra64/time.h"
#include "ultra64/vi.h"
#include "ultra64/pi.h"
#include "ultra64/controller.h"
#include "ultra64/printf.h"
#include "ultra64/mbi.h"
#include "ultra64/pfs.h"
#include "ultra64/motor.h"
#include "ultra64/r4300.h"
#endif

538
include/ultra64/abi.h
View File

@ -6,48 +6,48 @@
uintptr_t check_pointer(uintptr_t p, u32 sz);
/* Audio commands: */
#define A_SPNOOP 0
#define A_ADPCM 1
#define A_CLEARBUFF 2
#define A_UNK3 3
#define A_ADDMIXER 4
#define A_RESAMPLE 5
#define A_RESAMPLE_ZOH 6
#define A_FILTER 7
#define A_SETBUFF 8
#define A_DUPLICATE 9
#define A_DMEMMOVE 10
#define A_LOADADPCM 11
#define A_MIXER 12
#define A_INTERLEAVE 13
#define A_HILOGAIN 14
#define A_SETLOOP 15
#define A_INTERL 17
#define A_ENVSETUP1 18
#define A_ENVMIXER 19
#define A_LOADBUFF 20
#define A_SAVEBUFF 21
#define A_ENVSETUP2 22
#define A_S8DEC 23
#define A_UNK19 25
#define A_SPNOOP 0
#define A_ADPCM 1
#define A_CLEARBUFF 2
#define A_UNK3 3
#define A_ADDMIXER 4
#define A_RESAMPLE 5
#define A_RESAMPLE_ZOH 6
#define A_FILTER 7
#define A_SETBUFF 8
#define A_DUPLICATE 9
#define A_DMEMMOVE 10
#define A_LOADADPCM 11
#define A_MIXER 12
#define A_INTERLEAVE 13
#define A_HILOGAIN 14
#define A_SETLOOP 15
#define A_INTERL 17
#define A_ENVSETUP1 18
#define A_ENVMIXER 19
#define A_LOADBUFF 20
#define A_SAVEBUFF 21
#define A_ENVSETUP2 22
#define A_S8DEC 23
#define A_UNK19 25
#define ACMD_SIZE 32
/*
* Audio flags
*/
#define A_INIT 0x01
#define A_CONTINUE 0x00
#define A_LOOP 0x02
#define A_OUT 0x02
#define A_LEFT 0x02
#define A_RIGHT 0x00
#define A_VOL 0x04
#define A_RATE 0x00
#define A_AUX 0x08
#define A_NOAUX 0x00
#define A_MAIN 0x00
#define A_MIX 0x10
#define A_INIT 0x01
#define A_CONTINUE 0x00
#define A_LOOP 0x02
#define A_OUT 0x02
#define A_LEFT 0x02
#define A_RIGHT 0x00
#define A_VOL 0x04
#define A_RATE 0x00
#define A_AUX 0x08
#define A_NOAUX 0x00
#define A_MAIN 0x00
#define A_MIX 0x10
/*
* Data Structures.
@ -255,9 +255,9 @@ struct Asegment
#ifdef LITTLE_ENDIAN
u32 pad1 : 24;
u32 cmd : 8;
u32 pad3 : 2;
u32 pad3 : 2;
u32 base : 24;
u32 number : 4;
u32 number : 4;
u32 pad2 : 2;
#else
u32 cmd : 8;
@ -371,34 +371,35 @@ struct Asetloop
* Generic Acmd Packet
*/
struct Awords {
uintptr_t w0;
uintptr_t w1;
struct Awords
{
uintptr_t w0;
uintptr_t w1;
};
union Acmd
{
Awords words;
Aadpcm adpcm;
Apolef polef;
Aclearbuff clearbuff;
Aenvelope envelope;
Ainterleave interleave;
Aloadbuff loadbuff;
Aenvmixer envmixer;
Aresample resample;
Areverb reverb;
Asavebuff savebuff;
Asegment segment;
Asetbuff setbuff;
Asetvol setvol;
Admemmove dmemmove;
Aloadadpcm loadadpcm;
Amixer mixer;
Asetloop setloop;
Afilter filter;
Aduplicate duplicate;
long long int force_union_align; /* dummy, force alignment */
Awords words;
Aadpcm adpcm;
Apolef polef;
Aclearbuff clearbuff;
Aenvelope envelope;
Ainterleave interleave;
Aloadbuff loadbuff;
Aenvmixer envmixer;
Aresample resample;
Areverb reverb;
Asavebuff savebuff;
Asegment segment;
Asetbuff setbuff;
Asetvol setvol;
Admemmove dmemmove;
Aloadadpcm loadadpcm;
Amixer mixer;
Asetloop setloop;
Afilter filter;
Aduplicate duplicate;
long long int force_union_align; /* dummy, force alignment */
};
/*
@ -433,249 +434,228 @@ typedef short ENVMIX_STATE[40];
* Macros to assemble the audio command list
*/
#define aADPCMdec(pkt, f, s) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_ADPCM, 24, 8) | _SHIFTL(f, 16, 8); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aADPCMdec(pkt, f, s) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_ADPCM, 24, 8) | _SHIFTL(f, 16, 8); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aPoleFilter(pkt, f, g, s) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_POLEF, 24, 8) | _SHIFTL(f, 16, 8) | \
_SHIFTL(g, 0, 16)); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aPoleFilter(pkt, f, g, s) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_POLEF, 24, 8) | _SHIFTL(f, 16, 8) | _SHIFTL(g, 0, 16)); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aHiLoGain(pkt, gain, count, dmem, a4) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_HILOGAIN, 24, 8) | \
_SHIFTL(gain, 16, 8) | _SHIFTL(count, 0, 16)); \
_a->words.w1 = _SHIFTL(dmem, 16, 16) | _SHIFTL(a4, 0, 16); \
}
#define aHiLoGain(pkt, gain, count, dmem, a4) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_HILOGAIN, 24, 8) | _SHIFTL(gain, 16, 8) | _SHIFTL(count, 0, 16)); \
_a->words.w1 = _SHIFTL(dmem, 16, 16) | _SHIFTL(a4, 0, 16); \
}
#define aUnkCmd3(pkt, a1, a2, a3) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_UNK3, 24, 8) | _SHIFTL(a3, 0, 16); \
_a->words.w1 = _SHIFTL(a1, 16, 16) | _SHIFTL(a2, 0, 16); \
}
#define aUnkCmd3(pkt, a1, a2, a3) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_UNK3, 24, 8) | _SHIFTL(a3, 0, 16); \
_a->words.w1 = _SHIFTL(a1, 16, 16) | _SHIFTL(a2, 0, 16); \
}
#define aUnkCmd19(pkt, a1, a2, a3, a4) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_UNK19, 24, 8) | _SHIFTL(a1, 16, 8) | \
_SHIFTL(a2, 0, 16)); \
_a->words.w1 = _SHIFTL(a3, 16, 16) | _SHIFTL(a4, 0, 16); \
}
#define aUnkCmd19(pkt, a1, a2, a3, a4) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_UNK19, 24, 8) | _SHIFTL(a1, 16, 8) | _SHIFTL(a2, 0, 16)); \
_a->words.w1 = _SHIFTL(a3, 16, 16) | _SHIFTL(a4, 0, 16); \
}
#define aS8Dec(pkt, a1, a2) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_S8DEC, 24, 8) | _SHIFTL(a1, 16, 8); \
_a->words.w1 = (uintptr_t)(a2); \
}
#define aS8Dec(pkt, a1, a2) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_S8DEC, 24, 8) | _SHIFTL(a1, 16, 8); \
_a->words.w1 = (uintptr_t)(a2); \
}
#define aClearBuffer(pkt, d, c) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_CLEARBUFF, 24, 8) | _SHIFTL(d, 0, 24); \
_a->words.w1 = (uintptr_t)(c); \
}
#define aClearBuffer(pkt, d, c) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_CLEARBUFF, 24, 8) | _SHIFTL(d, 0, 24); \
_a->words.w1 = (uintptr_t)(c); \
}
#define aEnvMixer(pkt, dmemi, count, swapLR, x0, x1, x2, x3, m, bits) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (bits | _SHIFTL(dmemi >> 4, 16, 8) | \
_SHIFTL(count, 8, 8) | _SHIFTL(swapLR, 4, 1) | \
_SHIFTL(x0, 3, 1) | _SHIFTL(x1, 2, 1) | \
_SHIFTL(x2, 1, 1) | _SHIFTL(x3, 0, 1)); \
_a->words.w1 = (uintptr_t)(m); \
}
#define aEnvMixer(pkt, dmemi, count, swapLR, x0, x1, x2, x3, m, bits) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (bits | _SHIFTL(dmemi >> 4, 16, 8) | _SHIFTL(count, 8, 8) | _SHIFTL(swapLR, 4, 1) | _SHIFTL(x0, 3, 1) | _SHIFTL(x1, 2, 1) | _SHIFTL(x2, 1, 1) | _SHIFTL(x3, 0, 1)); \
_a->words.w1 = (uintptr_t)(m); \
}
#define aInterleave(pkt, o, l, r, c) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_INTERLEAVE, 24, 8) | \
_SHIFTL(c >> 4, 16, 8) | _SHIFTL(o, 0, 16)); \
_a->words.w1 = _SHIFTL(l, 16, 16) | _SHIFTL(r, 0, 16); \
}
#define aInterleave(pkt, o, l, r, c) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_INTERLEAVE, 24, 8) | _SHIFTL(c >> 4, 16, 8) | _SHIFTL(o, 0, 16)); \
_a->words.w1 = _SHIFTL(l, 16, 16) | _SHIFTL(r, 0, 16); \
}
#define aInterl(pkt, dmemi, dmemo, count) \
{ \
Acmd *_a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_INTERL, 24, 8) | _SHIFTL(count, 0, 16)); \
_a->words.w1 = _SHIFTL(dmemi, 16, 16) | _SHIFTL(dmemo, 0, 16); \
}
#define aInterl(pkt, dmemi, dmemo, count) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_INTERL, 24, 8) | _SHIFTL(count, 0, 16)); \
_a->words.w1 = _SHIFTL(dmemi, 16, 16) | _SHIFTL(dmemo, 0, 16); \
}
#define aLoadBuffer(pkt, s, d, c) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_LOADBUFF, 24, 8) | \
_SHIFTL((c) >> 4, 16, 8) | _SHIFTL(d, 0, 16)); \
_a->words.w1 = check_pointer((uintptr_t)(s), c); \
}
#define aLoadBuffer(pkt, s, d, c) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_LOADBUFF, 24, 8) | _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(d, 0, 16)); \
_a->words.w1 = check_pointer((uintptr_t)(s), c); \
}
#define aMix(pkt, f, g, i, o) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_MIXER, 24, 8) | _SHIFTL(f, 16, 8) | \
_SHIFTL(g, 0, 16)); \
_a->words.w1 = _SHIFTL(i, 16, 16) | _SHIFTL(o, 0, 16); \
}
#define aMix(pkt, f, g, i, o) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_MIXER, 24, 8) | _SHIFTL(f, 16, 8) | _SHIFTL(g, 0, 16)); \
_a->words.w1 = _SHIFTL(i, 16, 16) | _SHIFTL(o, 0, 16); \
}
#define aPan(pkt, f, d, s) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_PAN, 24, 8) | _SHIFTL(f, 16, 8) | \
_SHIFTL(d, 0, 16)); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aPan(pkt, f, d, s) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_PAN, 24, 8) | _SHIFTL(f, 16, 8) | _SHIFTL(d, 0, 16)); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aResample(pkt, f, p, s) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_RESAMPLE, 24, 8) | \
_SHIFTL(f, 16, 8) | _SHIFTL(p, 0, 16)); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aResample(pkt, f, p, s) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_RESAMPLE, 24, 8) | _SHIFTL(f, 16, 8) | _SHIFTL(p, 0, 16)); \
_a->words.w1 = (uintptr_t)(s); \
}
#define aSaveBuffer(pkt, s, d, c) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SAVEBUFF, 24, 8) | \
_SHIFTL((c) >> 4, 16, 8) | _SHIFTL(s, 0, 16)); \
_a->words.w1 = (uintptr_t)(d); \
}
#define aSaveBuffer(pkt, s, d, c) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SAVEBUFF, 24, 8) | _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(s, 0, 16)); \
_a->words.w1 = (uintptr_t)(d); \
}
#define aSegment(pkt, s, b) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_SEGMENT, 24, 8); \
_a->words.w1 = _SHIFTL(s, 24, 8) | _SHIFTL(b, 0, 24); \
}
#define aSegment(pkt, s, b) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_SEGMENT, 24, 8); \
_a->words.w1 = _SHIFTL(s, 24, 8) | _SHIFTL(b, 0, 24); \
}
#define aSetBuffer(pkt, f, i, o, c) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SETBUFF, 24, 8) | _SHIFTL(f, 16, 8) | \
_SHIFTL(i, 0, 16)); \
_a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \
}
#define aSetBuffer(pkt, f, i, o, c) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SETBUFF, 24, 8) | _SHIFTL(f, 16, 8) | _SHIFTL(i, 0, 16)); \
_a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \
}
#define aSetVolume(pkt, f, v, t, r) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SETVOL, 24, 8) | _SHIFTL(f, 16, 16) | \
_SHIFTL(v, 0, 16)); \
_a->words.w1 = _SHIFTL(r, 0, 16) | _SHIFTL(t, 16, 16); \
}
#define aSetVolume(pkt, f, v, t, r) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SETVOL, 24, 8) | _SHIFTL(f, 16, 16) | _SHIFTL(v, 0, 16)); \
_a->words.w1 = _SHIFTL(r, 0, 16) | _SHIFTL(t, 16, 16); \
}
#define aSetVolume32(pkt, f, v, tr) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SETVOL, 24, 8) | _SHIFTL(f, 16, 16) | \
_SHIFTL(v, 0, 16)); \
_a->words.w1 = (uintptr_t)(tr); \
}
#define aSetVolume32(pkt, f, v, tr) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_SETVOL, 24, 8) | _SHIFTL(f, 16, 16) | _SHIFTL(v, 0, 16)); \
_a->words.w1 = (uintptr_t)(tr); \
}
#define aSetLoop(pkt, a) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_SETLOOP, 24, 8); \
_a->words.w1 = (uintptr_t)(a); \
}
#define aSetLoop(pkt, a) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_SETLOOP, 24, 8); \
_a->words.w1 = (uintptr_t)(a); \
}
#define aDMEMMove(pkt, i, o, c) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_DMEMMOVE, 24, 8) | _SHIFTL(i, 0, 24); \
_a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \
}
#define aDMEMMove(pkt, i, o, c) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_DMEMMOVE, 24, 8) | _SHIFTL(i, 0, 24); \
_a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \
}
#define aLoadADPCM(pkt, c, d) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_LOADADPCM, 24, 8) | _SHIFTL(c, 0, 24); \
_a->words.w1 = check_pointer((uintptr_t)d, c); \
}
#define aLoadADPCM(pkt, c, d) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_LOADADPCM, 24, 8) | _SHIFTL(c, 0, 24); \
_a->words.w1 = check_pointer((uintptr_t)d, c); \
}
#define aEnvSetup1(pkt, a, b, c, d) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_ENVSETUP1, 24, 8) | \
_SHIFTL(a, 16, 8) | _SHIFTL(b, 0, 16)); \
_a->words.w1 = _SHIFTL(c, 16, 16) | _SHIFTL(d, 0, 16); \
}
#define aEnvSetup1(pkt, a, b, c, d) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_ENVSETUP1, 24, 8) | _SHIFTL(a, 16, 8) | _SHIFTL(b, 0, 16)); \
_a->words.w1 = _SHIFTL(c, 16, 16) | _SHIFTL(d, 0, 16); \
}
#define aEnvSetup2(pkt, volLeft, volRight) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = _SHIFTL(A_ENVSETUP2, 24, 8); \
_a->words.w1 = (_SHIFTL(volLeft, 16, 16) | \
_SHIFTL(volRight, 0, 16)); \
}
#define aEnvSetup2(pkt, volLeft, volRight) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = _SHIFTL(A_ENVSETUP2, 24, 8); \
_a->words.w1 = (_SHIFTL(volLeft, 16, 16) | _SHIFTL(volRight, 0, 16)); \
}
#define aFilter(pkt, f, countOrBuf, addr) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_FILTER, 24, 8) | _SHIFTL(f, 16, 8) | \
_SHIFTL(countOrBuf, 0, 16)); \
_a->words.w1 = (uintptr_t)(addr); \
}
#define aFilter(pkt, f, countOrBuf, addr) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_FILTER, 24, 8) | _SHIFTL(f, 16, 8) | _SHIFTL(countOrBuf, 0, 16)); \
_a->words.w1 = (uintptr_t)(addr); \
}
#define aDuplicate(pkt, count, dmemi, dmemo, a4) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_DUPLICATE, 24, 8) | \
_SHIFTL(count, 16, 8) | _SHIFTL(dmemi, 0, 16)); \
_a->words.w1 = _SHIFTL(dmemo, 16, 16) | _SHIFTL(a4, 0, 16); \
}
#define aDuplicate(pkt, count, dmemi, dmemo, a4) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_DUPLICATE, 24, 8) | _SHIFTL(count, 16, 8) | _SHIFTL(dmemi, 0, 16)); \
_a->words.w1 = _SHIFTL(dmemo, 16, 16) | _SHIFTL(a4, 0, 16); \
}
#define aAddMixer(pkt, count, dmemi, dmemo, a4) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_ADDMIXER, 24, 8) | \
_SHIFTL(count >> 4, 16, 8) | _SHIFTL(a4, 0, 16)); \
_a->words.w1 = _SHIFTL(dmemi, 16, 16) | _SHIFTL(dmemo, 0, 16); \
}
#define aAddMixer(pkt, count, dmemi, dmemo, a4) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_ADDMIXER, 24, 8) | _SHIFTL(count >> 4, 16, 8) | _SHIFTL(a4, 0, 16)); \
_a->words.w1 = _SHIFTL(dmemi, 16, 16) | _SHIFTL(dmemo, 0, 16); \
}
#define aResampleZoh(pkt, pitch, pitchAccu) \
{ \
Acmd *_a = (Acmd *)pkt; \
\
_a->words.w0 = (_SHIFTL(A_RESAMPLE_ZOH, 24, 8) | \
_SHIFTL(pitch, 0, 16)); \
_a->words.w1 = _SHIFTL(pitchAccu, 0, 16); \
}
#define aResampleZoh(pkt, pitch, pitchAccu) \
{ \
Acmd* _a = (Acmd*)pkt; \
\
_a->words.w0 = (_SHIFTL(A_RESAMPLE_ZOH, 24, 8) | _SHIFTL(pitch, 0, 16)); \
_a->words.w1 = _SHIFTL(pitchAccu, 0, 16); \
}
#endif /* ULTRA64_ABI_H */

191
include/ultra64/controller.h
View File

@ -7,10 +7,10 @@
#define SIAccessQueueSize 2
#define BLOCKSIZE 32
#define MAXCONTROLLERS 4
#define MAXCONTROLLERS 4
#define PFS_ONE_PAGE 8
#define PFS_PAGE_SIZE (BLOCKSIZE*PFS_ONE_PAGE)
#define PFS_PAGE_SIZE (BLOCKSIZE * PFS_ONE_PAGE)
#define CONT_CMD_REQUEST_STATUS 0
#define CONT_CMD_READ_BUTTON 1
@ -38,17 +38,16 @@
#define CONT_CMD_NOP 0xFF
#define CONT_CMD_END 0xFE // Indicates end of a command
#define CONT_CMD_EXE 1 // Set pif ram status byte to this to do a command
#define CONT_ERR_NO_CONTROLLER PFS_ERR_NOPACK /* 1 */
#define CONT_ERR_CONTRFAIL CONT_OVERRUN_ERROR /* 4 */
#define CONT_ERR_INVALID PFS_ERR_INVALID /* 5 */
#define CONT_ERR_DEVICE PFS_ERR_DEVICE /* 11 */
#define CONT_ERR_NOT_READY 12
#define CONT_ERR_VOICE_MEMORY 13
#define CONT_ERR_VOICE_WORD 14
#define CONT_ERR_VOICE_NO_RESPONSE 15
#define CONT_CMD_EXE 1 // Set pif ram status byte to this to do a command
#define CONT_ERR_NO_CONTROLLER PFS_ERR_NOPACK /* 1 */
#define CONT_ERR_CONTRFAIL CONT_OVERRUN_ERROR /* 4 */
#define CONT_ERR_INVALID PFS_ERR_INVALID /* 5 */
#define CONT_ERR_DEVICE PFS_ERR_DEVICE /* 11 */
#define CONT_ERR_NOT_READY 12
#define CONT_ERR_VOICE_MEMORY 13
#define CONT_ERR_VOICE_WORD 14
#define CONT_ERR_VOICE_NO_RESPONSE 15
#define DIR_STATUS_EMPTY 0
#define DIR_STATUS_UNKNOWN 1
@ -62,111 +61,119 @@
#define PFS_ERR_NOPACK 1
/* controller errors */
#define CONT_NO_RESPONSE_ERROR 0x8
#define CONT_OVERRUN_ERROR 0x4
#define CONT_NO_RESPONSE_ERROR 0x8
#define CONT_OVERRUN_ERROR 0x4
/* Controller type */
#define CONT_ABSOLUTE 0x0001
#define CONT_RELATIVE 0x0002
#define CONT_JOYPORT 0x0004
#define CONT_EEPROM 0x8000
#define CONT_EEP16K 0x4000
#define CONT_TYPE_MASK 0x1F07
#define CONT_TYPE_NORMAL 0x0005
#define CONT_TYPE_MOUSE 0x0002
#define CONT_TYPE_VOICE 0x0100
#define CONT_ABSOLUTE 0x0001
#define CONT_RELATIVE 0x0002
#define CONT_JOYPORT 0x0004
#define CONT_EEPROM 0x8000
#define CONT_EEP16K 0x4000
#define CONT_TYPE_MASK 0x1F07
#define CONT_TYPE_NORMAL 0x0005
#define CONT_TYPE_MOUSE 0x0002
#define CONT_TYPE_VOICE 0x0100
/* Controller status */
#define CONT_CARD_ON 0x01
#define CONT_CARD_PULL 0x02
#define CONT_ADDR_CRC_ER 0x04
#define CONT_EEPROM_BUSY 0x80
#define CONT_CARD_ON 0x01
#define CONT_CARD_PULL 0x02
#define CONT_ADDR_CRC_ER 0x04
#define CONT_EEPROM_BUSY 0x80
/* Buttons */
#define BTN_CRIGHT 0x0001
#define BTN_CLEFT 0x0002
#define BTN_CDOWN 0x0004
#define BTN_CUP 0x0008
#define BTN_R 0x0010
#define BTN_L 0x0020
#define BTN_DRIGHT 0x0100
#define BTN_DLEFT 0x0200
#define BTN_DDOWN 0x0400
#define BTN_DUP 0x0800
#define BTN_START 0x1000
#define BTN_Z 0x2000
#define BTN_B 0x4000
#define BTN_A 0x8000
#define BTN_CRIGHT 0x0001
#define BTN_CLEFT 0x0002
#define BTN_CDOWN 0x0004
#define BTN_CUP 0x0008
#define BTN_R 0x0010
#define BTN_L 0x0020
#define BTN_DRIGHT 0x0100
#define BTN_DLEFT 0x0200
#define BTN_DDOWN 0x0400
#define BTN_DUP 0x0800
#define BTN_START 0x1000
#define BTN_Z 0x2000
#define BTN_B 0x4000
#define BTN_A 0x8000
struct OSPifRam {
/* 0x00 */ u32 ram[15];
/* 0x3C */ uintptr_t status;
struct OSPifRam
{
/* 0x00 */ u32 ram[15];
/* 0x3C */ uintptr_t status;
}; // size = 0x40
struct OSContStatus {
/* 0x00 */ u16 type;
/* 0x02 */ u8 status;
/* 0x03 */ u8 errnum;
struct OSContStatus
{
/* 0x00 */ u16 type;
/* 0x02 */ u8 status;
/* 0x03 */ u8 errnum;
}; // size = 0x04
struct OSContPad {
/* 0x00 */ u16 button;
/* 0x02 */ s8 stick_x;
/* 0x03 */ s8 stick_y;
/* 0x04 */ u8 errnum;
struct OSContPad
{
/* 0x00 */ u16 button;
/* 0x02 */ s8 stick_x;
/* 0x03 */ s8 stick_y;
/* 0x04 */ u8 errnum;
}; // size = 0x06
struct OSContRamIo {
/* 0x00 */ void* address;
/* 0x04 */ u8 databuffer[32];
/* 0x24 */ u8 addressCrc;
/* 0x25 */ u8 dataCrc;
/* 0x26 */ u8 errnum;
struct OSContRamIo
{
/* 0x00 */ void* address;
/* 0x04 */ u8 databuffer[32];
/* 0x24 */ u8 addressCrc;
/* 0x25 */ u8 dataCrc;
/* 0x26 */ u8 errnum;
}; // size = 0x28
// Original name: __OSContRequesFormat
struct __OSContRequestHeader {
/* 0x00 */ u8 align;
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 poll;
/* 0x04 */ u8 typeh;
/* 0x05 */ u8 typel;
/* 0x06 */ u8 status;
/* 0x07 */ u8 align1;
struct __OSContRequestHeader
{
/* 0x00 */ u8 align;
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 poll;
/* 0x04 */ u8 typeh;
/* 0x05 */ u8 typel;
/* 0x06 */ u8 status;
/* 0x07 */ u8 align1;
}; // size = 0x8
// Original name: __OSContRequesHeaderFormatShort
struct __OSContRequestHeaderAligned {
/* 0x00 */ u8 txsize;
/* 0x01 */ u8 rxsize;
/* 0x02 */ u8 poll;
/* 0x03 */ u8 typeh;
/* 0x04 */ u8 typel;
/* 0x05 */ u8 status;
struct __OSContRequestHeaderAligned
{
/* 0x00 */ u8 txsize;
/* 0x01 */ u8 rxsize;
/* 0x02 */ u8 poll;
/* 0x03 */ u8 typeh;
/* 0x04 */ u8 typel;
/* 0x05 */ u8 status;
}; // size = 0x6
// Original Name: __OSContRamReadFormat
struct __OSContRamHeader {
/* 0x00 */ u8 unk_00;
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 poll;
/* 0x04 */ u8 hi;
/* 0x05 */ u8 lo;
/* 0x06 */ u8 data[BLOCKSIZE];
/* 0x26 */ u8 datacrc;
struct __OSContRamHeader
{
/* 0x00 */ u8 unk_00;
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 poll;
/* 0x04 */ u8 hi;
/* 0x05 */ u8 lo;
/* 0x06 */ u8 data[BLOCKSIZE];
/* 0x26 */ u8 datacrc;
}; // size = 0x27
// Original name: __OSContReadFormat
struct __OSContReadHeader {
/* 0x00 */ u8 align;
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 poll;
/* 0x04 */ u16 button;
/* 0x06 */ s8 joyX;
/* 0x07 */ s8 joyY;
struct __OSContReadHeader
{
/* 0x00 */ u8 align;
/* 0x01 */ u8 txsize;
/* 0x02 */ u8 rxsize;
/* 0x03 */ u8 poll;
/* 0x04 */ u16 button;
/* 0x06 */ s8 joyX;
/* 0x07 */ s8 joyY;
}; // size = 0x8
#endif

20
include/ultra64/convert.h
View File

@ -1,18 +1,18 @@
#ifndef ULTRA64_CONVERT_H
#define ULTRA64_CONVERT_H
#define OS_CLOCK_RATE 62500000LL
#define OS_CPU_COUNTER (OS_CLOCK_RATE*3/4)
#define OS_CLOCK_RATE 62500000LL
#define OS_CPU_COUNTER (OS_CLOCK_RATE * 3 / 4)
#define OS_NSEC_TO_CYCLES(n) (((u64)(n)*(OS_CPU_COUNTER/15625000LL))/(1000000000LL/15625000LL))
#define OS_USEC_TO_CYCLES(n) (((u64)(n)*(OS_CPU_COUNTER/15625LL))/(1000000LL/15625LL))
#define OS_CYCLES_TO_NSEC(c) (((u64)(c)*(1000000000LL/15625000LL))/(OS_CPU_COUNTER/15625000LL))
#define OS_CYCLES_TO_USEC(c) (((u64)(c)*(1000000LL/15625LL))/(OS_CPU_COUNTER/15625LL))
#define OS_NSEC_TO_CYCLES(n) (((u64)(n) * (OS_CPU_COUNTER / 15625000LL)) / (1000000000LL / 15625000LL))
#define OS_USEC_TO_CYCLES(n) (((u64)(n) * (OS_CPU_COUNTER / 15625LL)) / (1000000LL / 15625LL))
#define OS_CYCLES_TO_NSEC(c) (((u64)(c) * (1000000000LL / 15625000LL)) / (OS_CPU_COUNTER / 15625000LL))
#define OS_CYCLES_TO_USEC(c) (((u64)(c) * (1000000LL / 15625LL)) / (OS_CPU_COUNTER / 15625LL))
#define OS_K0_TO_PHYSICAL(x) (uintptr_t)(x)
#define OS_K1_TO_PHYSICAL(x) (uintptr_t)(x)
#define OS_K0_TO_PHYSICAL(x) (uintptr_t)(x)
#define OS_K1_TO_PHYSICAL(x) (uintptr_t)(x)
#define OS_PHYSICAL_TO_K0(x) (void*)(x)
#define OS_PHYSICAL_TO_K1(x) (void*)(x)
#define OS_PHYSICAL_TO_K0(x) (void*)(x)
#define OS_PHYSICAL_TO_K1(x) (void*)(x)
#endif

43
include/ultra64/exception.h
View File

@ -4,32 +4,33 @@
#include "types.h"
// Interrupt masks
#define OS_IM_NONE 0x00000001
#define OS_IM_SW1 0x00000501
#define OS_IM_SW2 0x00000601
#define OS_IM_CART 0x00000C01
#define OS_IM_PRENMI 0x00001401
#define OS_IM_RDBWRITE 0x00002401
#define OS_IM_RDBREAD 0x00004401
#define OS_IM_COUNTER 0x00008401
#define OS_IM_CPU 0x0000FF01
#define OS_IM_SP 0x00010401
#define OS_IM_SI 0x00020401
#define OS_IM_AI 0x00040401
#define OS_IM_VI 0x00080401
#define OS_IM_PI 0x00100401
#define OS_IM_DP 0x00200401
#define OS_IM_ALL 0x003FFF01
#define OS_IM_NONE 0x00000001
#define OS_IM_SW1 0x00000501
#define OS_IM_SW2 0x00000601
#define OS_IM_CART 0x00000C01
#define OS_IM_PRENMI 0x00001401
#define OS_IM_RDBWRITE 0x00002401
#define OS_IM_RDBREAD 0x00004401
#define OS_IM_COUNTER 0x00008401
#define OS_IM_CPU 0x0000FF01
#define OS_IM_SP 0x00010401
#define OS_IM_SI 0x00020401
#define OS_IM_AI 0x00040401
#define OS_IM_VI 0x00080401
#define OS_IM_PI 0x00100401
#define OS_IM_DP 0x00200401
#define OS_IM_ALL 0x003FFF01
#define RCP_IMASK 0x003F0000
#define RCP_IMASKSHIFT 16
#define RCP_IMASK 0x003F0000
#define RCP_IMASKSHIFT 16
typedef u32 OSIntMask;
typedef u32 OSHWIntr;
struct __osHwInt {
/* 0x00 */ void* callback;
/* 0x04 */ void* sp;
struct __osHwInt
{
/* 0x00 */ void* callback;
/* 0x04 */ void* sp;
}; // size = 0x08
OSIntMask osSetIntMask(OSIntMask);

5694
include/ultra64/gbi.h
View File

File diff suppressed because it is too large Load Diff

519
include/ultra64/gs2dex.h
View File

@ -1,12 +1,12 @@
#ifndef GS2DEX_H
#define GS2DEX_H
#ifndef GS2DEX_H
#define GS2DEX_H
/*===========================================================================*
* Macro
*===========================================================================*/
#define GS_CALC_DXT(line) (((1<< G_TX_DXT_FRAC)-1)/(line)+1)
#define GS_PIX2TMEM(pix, siz) ((pix)>>(4-(siz)))
#define GS_PIX2DXT(pix, siz) GS_CALC_DXT(GS_PIX2TMEM((pix), (siz)))
#define GS_CALC_DXT(line) (((1 << G_TX_DXT_FRAC) - 1) / (line) + 1)
#define GS_PIX2TMEM(pix, siz) ((pix) >> (4 - (siz)))
#define GS_PIX2DXT(pix, siz) GS_CALC_DXT(GS_PIX2TMEM((pix), (siz)))
/*===========================================================================*
* Data structures for S2DEX microcode
@ -15,356 +15,373 @@
/*---------------------------------------------------------------------------*
* Background
*---------------------------------------------------------------------------*/
#define G_BGLT_LOADBLOCK 0x0033
#define G_BGLT_LOADTILE 0xfff4
#define G_BGLT_LOADBLOCK 0x0033
#define G_BGLT_LOADTILE 0xfff4
#define G_BG_FLAG_FLIPS 0x01
#define G_BG_FLAG_FLIPT 0x10
#define G_BG_FLAG_FLIPS 0x01
#define G_BG_FLAG_FLIPT 0x10
/* Non scalable background plane */
typedef struct {
u16 imageX; /* x-coordinate of upper-left position of texture (u10.5) */
u16 imageW; /* width of the texture (u10.2) */
s16 frameX; /* upper-left position of transferred frame (s10.2) */
u16 frameW; /* width of transferred frame (u10.2) */
typedef struct
{
u16 imageX; /* x-coordinate of upper-left position of texture (u10.5) */
u16 imageW; /* width of the texture (u10.2) */
s16 frameX; /* upper-left position of transferred frame (s10.2) */
u16 frameW; /* width of transferred frame (u10.2) */
u16 imageY; /* y-coordinate of upper-left position of texture (u10.5) */
u16 imageH; /* height of the texture (u10.2) */
s16 frameY; /* upper-left position of transferred frame (s10.2) */
u16 frameH; /* height of transferred frame (u10.2) */
u16 imageY; /* y-coordinate of upper-left position of texture (u10.5) */
u16 imageH; /* height of the texture (u10.2) */
s16 frameY; /* upper-left position of transferred frame (s10.2) */
u16 frameH; /* height of transferred frame (u10.2) */
u64 *imagePtr; /* texture source address on DRAM */
u16 imageLoad; /* which to use, LoadBlock or LoadTile */
u8 imageFmt; /* format of texel - G_IM_FMT_* */
u8 imageSiz; /* size of texel - G_IM_SIZ_* */
u16 imagePal; /* pallet number */
u16 imageFlip; /* right & left image inversion (Inverted by G_BG_FLAG_FLIPS) */
u64* imagePtr; /* texture source address on DRAM */
u16 imageLoad; /* which to use, LoadBlock or LoadTile */
u8 imageFmt; /* format of texel - G_IM_FMT_* */
u8 imageSiz; /* size of texel - G_IM_SIZ_* */
u16 imagePal; /* pallet number */
u16 imageFlip; /* right & left image inversion (Inverted by G_BG_FLAG_FLIPS) */
/* The following is set in the initialization routine guS2DInitBg(). There is no need for the user to set it. */
u16 tmemW; /* TMEM width and Word size of frame 1 line.
At LoadBlock, GS_PIX2TMEM(imageW/4,imageSiz)
At LoadTile GS_PIX2TMEM(frameW/4,imageSiz)+1 */
u16 tmemH; /* height of TMEM loadable at a time (s13.2) 4 times value
/* The following is set in the initialization routine guS2DInitBg(). There is no need for the user to set it. */
u16 tmemW; /* TMEM width and Word size of frame 1 line.
At LoadBlock, GS_PIX2TMEM(imageW/4,imageSiz)
At LoadTile GS_PIX2TMEM(frameW/4,imageSiz)+1 */
u16 tmemH; /* height of TMEM loadable at a time (s13.2) 4 times value
When the normal texture, 512/tmemW*4
When the CI texture, 256/tmemW*4 */
u16 tmemLoadSH; /* SH value
u16 tmemLoadSH; /* SH value
At LoadBlock, tmemSize/2-1
At LoadTile, tmemW*16-1 */
u16 tmemLoadTH; /* TH value or Stride value
u16 tmemLoadTH; /* TH value or Stride value
At LoadBlock, GS_CALC_DXT(tmemW)
At LoadTile, tmemH-1 */
u16 tmemSizeW; /* skip value of imagePtr for image 1-line
u16 tmemSizeW; /* skip value of imagePtr for image 1-line
At LoadBlock, tmemW*2
At LoadTile, GS_PIX2TMEM(imageW/4,imageSiz)*2 */
u16 tmemSize; /* skip value of imagePtr for 1-loading
At LoadTile, GS_PIX2TMEM(imageW/4,imageSiz)*2 */
u16 tmemSize; /* skip value of imagePtr for 1-loading
= tmemSizeW*tmemH */
} uObjBg_t; /* 40 bytes */
/* Scalable background plane */
typedef struct {
u16 imageX; /* x-coordinate of upper-left position of texture (u10.5) */
u16 imageW; /* width of texture (u10.2) */
s16 frameX; /* upper-left position of transferred frame (s10.2) */
u16 frameW; /* width of transferred frame (u10.2) */
typedef struct
{
u16 imageX; /* x-coordinate of upper-left position of texture (u10.5) */
u16 imageW; /* width of texture (u10.2) */
s16 frameX; /* upper-left position of transferred frame (s10.2) */
u16 frameW; /* width of transferred frame (u10.2) */
u16 imageY; /* y-coordinate of upper-left position of texture (u10.5) */
u16 imageH; /* height of texture (u10.2) */
s16 frameY; /* upper-left position of transferred frame (s10.2) */
u16 frameH; /* height of transferred frame (u10.2) */
u16 imageY; /* y-coordinate of upper-left position of texture (u10.5) */
u16 imageH; /* height of texture (u10.2) */
s16 frameY; /* upper-left position of transferred frame (s10.2) */
u16 frameH; /* height of transferred frame (u10.2) */
u64 *imagePtr; /* texture source address on DRAM */
u16 imageLoad; /* Which to use, LoadBlock or LoadTile? */
u8 imageFmt; /* format of texel - G_IM_FMT_* */
u8 imageSiz; /* size of texel - G_IM_SIZ_* */
u16 imagePal; /* pallet number */
u16 imageFlip; /* right & left image inversion (Inverted by G_BG_FLAG_FLIPS) */
u64* imagePtr; /* texture source address on DRAM */
u16 imageLoad; /* Which to use, LoadBlock or LoadTile? */
u8 imageFmt; /* format of texel - G_IM_FMT_* */
u8 imageSiz; /* size of texel - G_IM_SIZ_* */
u16 imagePal; /* pallet number */
u16 imageFlip; /* right & left image inversion (Inverted by G_BG_FLAG_FLIPS) */
u16 scaleW; /* scale value of X-direction (u5.10) */
u16 scaleH; /* scale value of Y-direction (u5.10) */
s32 imageYorig; /* start point of drawing on image (s20.5) */
u16 scaleW; /* scale value of X-direction (u5.10) */
u16 scaleH; /* scale value of Y-direction (u5.10) */
s32 imageYorig; /* start point of drawing on image (s20.5) */
u8 padding[4];
u8 padding[4];
} uObjScaleBg_t; /* 40 bytes */
} uObjScaleBg_t; /* 40 bytes */
union uObjBg {
uObjBg_t b;
uObjScaleBg_t s;
long long int force_structure_alignment;
union uObjBg
{
uObjBg_t b;
uObjScaleBg_t s;
long long int force_structure_alignment;
};
/*---------------------------------------------------------------------------*
* 2D Objects
*---------------------------------------------------------------------------*/
#define G_OBJ_FLAG_FLIPS 1<<0 /* inversion to S-direction */
#define G_OBJ_FLAG_FLIPT 1<<4 /* nversion to T-direction */
#define G_OBJ_FLAG_FLIPS 1 << 0 /* inversion to S-direction */
#define G_OBJ_FLAG_FLIPT 1 << 4 /* nversion to T-direction */
struct uObjSprite_t {
s16 objX; /* s10.2 OBJ x-coordinate of upper-left end */
u16 scaleW; /* u5.10 Scaling of u5.10 width direction */
u16 imageW; /* u10.5 width of u10.5 texture (length of S-direction) */
u16 paddingX; /* Unused - Always 0 */
s16 objY; /* s10.2 OBJ y-coordinate of s10.2 OBJ upper-left end */
u16 scaleH; /* u5.10 Scaling of u5.10 height direction */
u16 imageH; /* u10.5 height of u10.5 texture (length of T-direction) */
u16 paddingY; /* Unused - Always 0 */
u16 imageStride; /* folding width of texel (In units of 64bit word) */
u16 imageAdrs; /* texture header position in TMEM (In units of 64bit word) */
u8 imageFmt; /* format of texel - G_IM_FMT_* */
u8 imageSiz; /* size of texel - G_IM_SIZ_* */
u8 imagePal; /* pallet number (0-7) */
u8 imageFlags; /* The display flag - G_OBJ_FLAG_FLIP* */
}; /* 24 bytes */
struct uObjSprite_t
{
s16 objX; /* s10.2 OBJ x-coordinate of upper-left end */
u16 scaleW; /* u5.10 Scaling of u5.10 width direction */
u16 imageW; /* u10.5 width of u10.5 texture (length of S-direction) */
u16 paddingX; /* Unused - Always 0 */
s16 objY; /* s10.2 OBJ y-coordinate of s10.2 OBJ upper-left end */
u16 scaleH; /* u5.10 Scaling of u5.10 height direction */
u16 imageH; /* u10.5 height of u10.5 texture (length of T-direction) */
u16 paddingY; /* Unused - Always 0 */
u16 imageStride; /* folding width of texel (In units of 64bit word) */
u16 imageAdrs; /* texture header position in TMEM (In units of 64bit word) */
u8 imageFmt; /* format of texel - G_IM_FMT_* */
u8 imageSiz; /* size of texel - G_IM_SIZ_* */
u8 imagePal; /* pallet number (0-7) */
u8 imageFlags; /* The display flag - G_OBJ_FLAG_FLIP* */
}; /* 24 bytes */
union uObjSprite {
uObjSprite_t s;
long long int force_structure_alignment;
union uObjSprite
{
uObjSprite_t s;
long long int force_structure_alignment;
};
/*---------------------------------------------------------------------------*
* 2D Matrix
*---------------------------------------------------------------------------*/
struct uObjMtx_t {
s32 A, B, C, D; /* s15.16 */
s16 X, Y; /* s10.2 */
u16 BaseScaleX; /* u5.10 */
u16 BaseScaleY; /* u5.10 */
}; /* 24 bytes */
struct uObjMtx_t
{
s32 A, B, C, D; /* s15.16 */
s16 X, Y; /* s10.2 */
u16 BaseScaleX; /* u5.10 */
u16 BaseScaleY; /* u5.10 */
}; /* 24 bytes */
union uObjMtx {
uObjMtx_t m;
long long int force_structure_alignment;
union uObjMtx
{
uObjMtx_t m;
long long int force_structure_alignment;
};
struct uObjSubMtx_t {
s16 X, Y; /* s10.2 */
u16 BaseScaleX; /* u5.10 */
u16 BaseScaleY; /* u5.10 */
}; /* 8 bytes */
struct uObjSubMtx_t
{
s16 X, Y; /* s10.2 */
u16 BaseScaleX; /* u5.10 */
u16 BaseScaleY; /* u5.10 */
}; /* 8 bytes */
union uObjSubMtx {
uObjSubMtx_t m;
long long int force_structure_alignment;
union uObjSubMtx
{
uObjSubMtx_t m;
long long int force_structure_alignment;
};
/*---------------------------------------------------------------------------*
* Loading into TMEM
*---------------------------------------------------------------------------*/
#define G_OBJLT_TXTRBLOCK 0x00001033
#define G_OBJLT_TXTRTILE 0x00fc1034
#define G_OBJLT_TLUT 0x00000030
#define G_OBJLT_TXTRBLOCK 0x00001033
#define G_OBJLT_TXTRTILE 0x00fc1034
#define G_OBJLT_TLUT 0x00000030
#define GS_TB_TSIZE(pix,siz) (GS_PIX2TMEM((pix),(siz))-1)
#define GS_TB_TLINE(pix,siz) (GS_CALC_DXT(GS_PIX2TMEM((pix),(siz))))
#define GS_TB_TSIZE(pix, siz) (GS_PIX2TMEM((pix), (siz)) - 1)
#define GS_TB_TLINE(pix, siz) (GS_CALC_DXT(GS_PIX2TMEM((pix), (siz))))
typedef struct {
u32 type; /* G_OBJLT_TXTRBLOCK divided into types */
u64 *image; /* texture source address on DRAM */
u16 tmem; /* loaded TMEM word address (8byteWORD) */
u16 tsize; /* Texture size, Specified by macro GS_TB_TSIZE() */
u16 tline; /* width of Texture 1-line, Specified by macro GS_TB_TLINE() */
u16 sid; /* STATE ID Multipled by 4 (Either one of 0, 4, 8 and 12) */
u32 flag; /* STATE flag */
u32 mask; /* STATE mask */
} uObjTxtrBlock_t; /* 24 bytes */
typedef struct
{
u32 type; /* G_OBJLT_TXTRBLOCK divided into types */
u64* image; /* texture source address on DRAM */
u16 tmem; /* loaded TMEM word address (8byteWORD) */
u16 tsize; /* Texture size, Specified by macro GS_TB_TSIZE() */
u16 tline; /* width of Texture 1-line, Specified by macro GS_TB_TLINE() */
u16 sid; /* STATE ID Multipled by 4 (Either one of 0, 4, 8 and 12) */
u32 flag; /* STATE flag */
u32 mask; /* STATE mask */
} uObjTxtrBlock_t; /* 24 bytes */
#define GS_TT_TWIDTH(pix,siz) ((GS_PIX2TMEM((pix), (siz))<<2)-1)
#define GS_TT_THEIGHT(pix,siz) (((pix)<<2)-1)
#define GS_TT_TWIDTH(pix, siz) ((GS_PIX2TMEM((pix), (siz)) << 2) - 1)
#define GS_TT_THEIGHT(pix, siz) (((pix) << 2) - 1)
typedef struct {
u32 type; /* G_OBJLT_TXTRTILE divided into types */
u64 *image; /* texture source address on DRAM */
u16 tmem; /* loaded TMEM word address (8byteWORD)*/
u16 twidth; /* width of Texture (Specified by macro GS_TT_TWIDTH()) */
u16 theight; /* height of Texture (Specified by macro GS_TT_THEIGHT()) */
u16 sid; /* STATE ID Multipled by 4 (Either one of 0, 4, 8 and 12) */
u32 flag; /* STATE flag */
u32 mask; /* STATE mask */
} uObjTxtrTile_t; /* 24 bytes */
typedef struct
{
u32 type; /* G_OBJLT_TXTRTILE divided into types */
u64* image; /* texture source address on DRAM */
u16 tmem; /* loaded TMEM word address (8byteWORD)*/
u16 twidth; /* width of Texture (Specified by macro GS_TT_TWIDTH()) */
u16 theight; /* height of Texture (Specified by macro GS_TT_THEIGHT()) */
u16 sid; /* STATE ID Multipled by 4 (Either one of 0, 4, 8 and 12) */
u32 flag; /* STATE flag */
u32 mask; /* STATE mask */
} uObjTxtrTile_t; /* 24 bytes */
#define GS_PAL_HEAD(head) ((head)+256)
#define GS_PAL_NUM(num) ((num)-1)
#define GS_PAL_HEAD(head) ((head) + 256)
#define GS_PAL_NUM(num) ((num)-1)
typedef struct {
u32 type; /* G_OBJLT_TLUT divided into types */
u64 *image; /* texture source address on DRAM */
u16 phead; /* pallet number of load header (Between 256 and 511) */
u16 pnum; /* loading pallet number -1 */
u16 zero; /* Assign 0 all the time */
u16 sid; /* STATE ID Multipled by 4 (Either one of 0, 4, 8 and 12)*/
u32 flag; /* STATE flag */
u32 mask; /* STATE mask */
} uObjTxtrTLUT_t; /* 24 bytes */
typedef struct
{
u32 type; /* G_OBJLT_TLUT divided into types */
u64* image; /* texture source address on DRAM */
u16 phead; /* pallet number of load header (Between 256 and 511) */
u16 pnum; /* loading pallet number -1 */
u16 zero; /* Assign 0 all the time */
u16 sid; /* STATE ID Multipled by 4 (Either one of 0, 4, 8 and 12)*/
u32 flag; /* STATE flag */
u32 mask; /* STATE mask */
} uObjTxtrTLUT_t; /* 24 bytes */
union uObjTxtr {
uObjTxtrBlock_t block;
uObjTxtrTile_t tile;
uObjTxtrTLUT_t tlut;
long long int force_structure_alignment;
union uObjTxtr
{
uObjTxtrBlock_t block;
uObjTxtrTile_t tile;
uObjTxtrTLUT_t tlut;
long long int force_structure_alignment;
};
/*---------------------------------------------------------------------------*
* Loading into TMEM & 2D Objects
*---------------------------------------------------------------------------*/
typedef struct {
uObjTxtr txtr;
uObjSprite sprite;
} uObjTxSprite; /* 48 bytes */
typedef struct
{
uObjTxtr txtr;
uObjSprite sprite;
} uObjTxSprite; /* 48 bytes */
/*===========================================================================*
* GBI Commands for S2DEX microcode
*===========================================================================*/
/* GBI Header */
#ifdef F3DEX_GBI_2
#define G_OBJ_RECTANGLE_R 0xda
#define G_OBJ_MOVEMEM 0xdc
#define G_RDPHALF_0 0xe4
#define G_OBJ_RECTANGLE 0x01
#define G_OBJ_SPRITE 0x02
#define G_SELECT_DL 0x04
#define G_OBJ_LOADTXTR 0x05
#define G_OBJ_LDTX_SPRITE 0x06
#define G_OBJ_LDTX_RECT 0x07
#define G_OBJ_LDTX_RECT_R 0x08
#define G_BG_1CYC 0x09
#define G_BG_COPY 0x0a
#define G_OBJ_RENDERMODE 0x0b
#ifdef F3DEX_GBI_2
#define G_OBJ_RECTANGLE_R 0xda
#define G_OBJ_MOVEMEM 0xdc
#define G_RDPHALF_0 0xe4
#define G_OBJ_RECTANGLE 0x01
#define G_OBJ_SPRITE 0x02
#define G_SELECT_DL 0x04
#define G_OBJ_LOADTXTR 0x05
#define G_OBJ_LDTX_SPRITE 0x06
#define G_OBJ_LDTX_RECT 0x07
#define G_OBJ_LDTX_RECT_R 0x08
#define G_BG_1CYC 0x09
#define G_BG_COPY 0x0a
#define G_OBJ_RENDERMODE 0x0b
#else
#define G_BG_1CYC 0x01
#define G_BG_COPY 0x02
#define G_OBJ_RECTANGLE 0x03
#define G_OBJ_SPRITE 0x04
#define G_OBJ_MOVEMEM 0x05
#define G_SELECT_DL 0xb0
#define G_OBJ_RENDERMODE 0xb1
#define G_OBJ_RECTANGLE_R 0xb2
#define G_OBJ_LOADTXTR 0xc1
#define G_OBJ_LDTX_SPRITE 0xc2
#define G_OBJ_LDTX_RECT 0xc3
#define G_OBJ_LDTX_RECT_R 0xc4
#define G_RDPHALF_0 0xe4
#define G_BG_1CYC 0x01
#define G_BG_COPY 0x02
#define G_OBJ_RECTANGLE 0x03
#define G_OBJ_SPRITE 0x04
#define G_OBJ_MOVEMEM 0x05
#define G_SELECT_DL 0xb0
#define G_OBJ_RENDERMODE 0xb1
#define G_OBJ_RECTANGLE_R 0xb2
#define G_OBJ_LOADTXTR 0xc1
#define G_OBJ_LDTX_SPRITE 0xc2
#define G_OBJ_LDTX_RECT 0xc3
#define G_OBJ_LDTX_RECT_R 0xc4
#define G_RDPHALF_0 0xe4
#endif
/*---------------------------------------------------------------------------*
* Background wrapped screen
*---------------------------------------------------------------------------*/
#define gSPBgRectangle(pkt, m, mptr) gDma0p((pkt),(m),(mptr),0)
#define gsSPBgRectangle(m, mptr) gsDma0p( (m),(mptr),0)
#define gSPBgRectCopy(pkt, mptr) gSPBgRectangle((pkt), G_BG_COPY, (mptr))
#define gsSPBgRectCopy(mptr) gsSPBgRectangle( G_BG_COPY, (mptr))
#define gSPBgRect1Cyc(pkt, mptr) gSPBgRectangle((pkt), G_BG_1CYC, (mptr))
#define gsSPBgRect1Cyc(mptr) gsSPBgRectangle( G_BG_1CYC, (mptr))
#define gSPBgRectangle(pkt, m, mptr) gDma0p((pkt), (m), (mptr), 0)
#define gsSPBgRectangle(m, mptr) gsDma0p((m), (mptr), 0)
#define gSPBgRectCopy(pkt, mptr) gSPBgRectangle((pkt), G_BG_COPY, (mptr))
#define gsSPBgRectCopy(mptr) gsSPBgRectangle(G_BG_COPY, (mptr))
#define gSPBgRect1Cyc(pkt, mptr) gSPBgRectangle((pkt), G_BG_1CYC, (mptr))
#define gsSPBgRect1Cyc(mptr) gsSPBgRectangle(G_BG_1CYC, (mptr))
/*---------------------------------------------------------------------------*
* 2D Objects
*---------------------------------------------------------------------------*/
#define gSPObjSprite(pkt, mptr) gDma0p((pkt),G_OBJ_SPRITE, (mptr),0)
#define gsSPObjSprite(mptr) gsDma0p( G_OBJ_SPRITE, (mptr),0)
#define gSPObjRectangle(pkt, mptr) gDma0p((pkt),G_OBJ_RECTANGLE, (mptr),0)
#define gsSPObjRectangle(mptr) gsDma0p( G_OBJ_RECTANGLE, (mptr),0)
#define gSPObjRectangleR(pkt, mptr) gDma0p((pkt),G_OBJ_RECTANGLE_R,(mptr),0)
#define gsSPObjRectangleR(mptr) gsDma0p( G_OBJ_RECTANGLE_R,(mptr),0)
#define gSPObjSprite(pkt, mptr) gDma0p((pkt), G_OBJ_SPRITE, (mptr), 0)
#define gsSPObjSprite(mptr) gsDma0p(G_OBJ_SPRITE, (mptr), 0)
#define gSPObjRectangle(pkt, mptr) gDma0p((pkt), G_OBJ_RECTANGLE, (mptr), 0)
#define gsSPObjRectangle(mptr) gsDma0p(G_OBJ_RECTANGLE, (mptr), 0)
#define gSPObjRectangleR(pkt, mptr) gDma0p((pkt), G_OBJ_RECTANGLE_R, (mptr), 0)
#define gsSPObjRectangleR(mptr) gsDma0p(G_OBJ_RECTANGLE_R, (mptr), 0)
/*---------------------------------------------------------------------------*
* 2D Matrix
*---------------------------------------------------------------------------*/
#define gSPObjMatrix(pkt, mptr) gDma1p((pkt),G_OBJ_MOVEMEM,(mptr),0,23)
#define gsSPObjMatrix(mptr) gsDma1p( G_OBJ_MOVEMEM,(mptr),0,23)
#define gSPObjSubMatrix(pkt, mptr) gDma1p((pkt),G_OBJ_MOVEMEM,(mptr),2, 7)
#define gsSPObjSubMatrix(mptr) gsDma1p( G_OBJ_MOVEMEM,(mptr),2, 7)
#define gSPObjMatrix(pkt, mptr) gDma1p((pkt), G_OBJ_MOVEMEM, (mptr), 0, 23)
#define gsSPObjMatrix(mptr) gsDma1p(G_OBJ_MOVEMEM, (mptr), 0, 23)
#define gSPObjSubMatrix(pkt, mptr) gDma1p((pkt), G_OBJ_MOVEMEM, (mptr), 2, 7)
#define gsSPObjSubMatrix(mptr) gsDma1p(G_OBJ_MOVEMEM, (mptr), 2, 7)
/*---------------------------------------------------------------------------*
* Loading into TMEM
*---------------------------------------------------------------------------*/
#define gSPObjLoadTxtr(pkt, tptr) gDma0p((pkt),G_OBJ_LOADTXTR, (tptr),23)
#define gsSPObjLoadTxtr(tptr) gsDma0p( G_OBJ_LOADTXTR, (tptr),23)
#define gSPObjLoadTxSprite(pkt, tptr) gDma0p((pkt),G_OBJ_LDTX_SPRITE,(tptr),47)
#define gsSPObjLoadTxSprite(tptr) gsDma0p( G_OBJ_LDTX_SPRITE,(tptr),47)
#define gSPObjLoadTxRect(pkt, tptr) gDma0p((pkt),G_OBJ_LDTX_RECT, (tptr),47)
#define gsSPObjLoadTxRect(tptr) gsDma0p( G_OBJ_LDTX_RECT, (tptr),47)
#define gSPObjLoadTxRectR(pkt, tptr) gDma0p((pkt),G_OBJ_LDTX_RECT_R,(tptr),47)
#define gsSPObjLoadTxRectR(tptr) gsDma0p( G_OBJ_LDTX_RECT_R,(tptr),47)
#define gSPObjLoadTxtr(pkt, tptr) gDma0p((pkt), G_OBJ_LOADTXTR, (tptr), 23)
#define gsSPObjLoadTxtr(tptr) gsDma0p(G_OBJ_LOADTXTR, (tptr), 23)
#define gSPObjLoadTxSprite(pkt, tptr) gDma0p((pkt), G_OBJ_LDTX_SPRITE, (tptr), 47)
#define gsSPObjLoadTxSprite(tptr) gsDma0p(G_OBJ_LDTX_SPRITE, (tptr), 47)
#define gSPObjLoadTxRect(pkt, tptr) gDma0p((pkt), G_OBJ_LDTX_RECT, (tptr), 47)
#define gsSPObjLoadTxRect(tptr) gsDma0p(G_OBJ_LDTX_RECT, (tptr), 47)
#define gSPObjLoadTxRectR(pkt, tptr) gDma0p((pkt), G_OBJ_LDTX_RECT_R, (tptr), 47)
#define gsSPObjLoadTxRectR(tptr) gsDma0p(G_OBJ_LDTX_RECT_R, (tptr), 47)
/*---------------------------------------------------------------------------*
* Select Display List
*---------------------------------------------------------------------------*/
#define gSPSelectDL(pkt, mptr, sid, flag, mask) \
{ gDma1p((pkt), G_RDPHALF_0, (flag), (u32)(mptr) & 0xffff, (sid)); \
gDma1p((pkt), G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_PUSH); }
#define gsSPSelectDL(mptr, sid, flag, mask) \
{ gsDma1p(G_RDPHALF_0, (flag), (u32)(mptr) & 0xffff, (sid)); \
gsDma1p(G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_PUSH); }
#define gSPSelectBranchDL(pkt, mptr, sid, flag, mask) \
{ gDma1p((pkt), G_RDPHALF_0, (flag), (u32)(mptr) & 0xffff, (sid)); \
gDma1p((pkt), G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_NOPUSH); }
#define gsSPSelectBranchDL(mptr, sid, flag, mask) \
{ gsDma1p(G_RDPHALF_0, (flag), (u32)(mptr) & 0xffff, (sid)); \
gsDma1p(G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_NOPUSH); }
#define gSPSelectDL(pkt, mptr, sid, flag, mask) \
{ \
gDma1p((pkt), G_RDPHALF_0, (flag), (u32)(mptr)&0xffff, (sid)); \
gDma1p((pkt), G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_PUSH); \
}
#define gsSPSelectDL(mptr, sid, flag, mask) \
{ \
gsDma1p(G_RDPHALF_0, (flag), (u32)(mptr)&0xffff, (sid)); \
gsDma1p(G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_PUSH); \
}
#define gSPSelectBranchDL(pkt, mptr, sid, flag, mask) \
{ \
gDma1p((pkt), G_RDPHALF_0, (flag), (u32)(mptr)&0xffff, (sid)); \
gDma1p((pkt), G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_NOPUSH); \
}
#define gsSPSelectBranchDL(mptr, sid, flag, mask) \
{ \
gsDma1p(G_RDPHALF_0, (flag), (u32)(mptr)&0xffff, (sid)); \
gsDma1p(G_SELECT_DL, (mask), (u32)(mptr) >> 16, G_DL_NOPUSH); \
}
/*---------------------------------------------------------------------------*
* Set general status
*---------------------------------------------------------------------------*/
#define G_MW_GENSTAT 0x08 /* Note that it is the same value of G_MW_FOG */
#define G_MW_GENSTAT 0x08 /* Note that it is the same value of G_MW_FOG */
#define gSPSetStatus(pkt, sid, val) \
gMoveWd((pkt), G_MW_GENSTAT, (sid), (val))
#define gsSPSetStatus(sid, val) \
gsMoveWd( G_MW_GENSTAT, (sid), (val))
#define gSPSetStatus(pkt, sid, val) gMoveWd((pkt), G_MW_GENSTAT, (sid), (val))
#define gsSPSetStatus(sid, val) gsMoveWd(G_MW_GENSTAT, (sid), (val))
/*---------------------------------------------------------------------------*
* Set Object Render Mode
*---------------------------------------------------------------------------*/
#define G_OBJRM_NOTXCLAMP 0x01
#define G_OBJRM_XLU 0x02 /* Ignored */
#define G_OBJRM_ANTIALIAS 0x04 /* Ignored */
#define G_OBJRM_BILERP 0x08
#define G_OBJRM_SHRINKSIZE_1 0x10
#define G_OBJRM_SHRINKSIZE_2 0x20
#define G_OBJRM_WIDEN 0x40
#define G_OBJRM_NOTXCLAMP 0x01
#define G_OBJRM_XLU 0x02 /* Ignored */
#define G_OBJRM_ANTIALIAS 0x04 /* Ignored */
#define G_OBJRM_BILERP 0x08
#define G_OBJRM_SHRINKSIZE_1 0x10
#define G_OBJRM_SHRINKSIZE_2 0x20
#define G_OBJRM_WIDEN 0x40
#define gSPObjRenderMode(pkt, mode) gImmp1((pkt),G_OBJ_RENDERMODE,(mode))
#define gsSPObjRenderMode(mode) gsImmp1( G_OBJ_RENDERMODE,(mode))
#define gSPObjRenderMode(pkt, mode) gImmp1((pkt), G_OBJ_RENDERMODE, (mode))
#define gsSPObjRenderMode(mode) gsImmp1(G_OBJ_RENDERMODE, (mode))
/*===========================================================================*
* Render Mode Macro
*===========================================================================*/
#define RM_RA_SPRITE(clk) \
AA_EN | CVG_DST_CLAMP | \
CVG_X_ALPHA | ALPHA_CVG_SEL | ZMODE_OPA | TEX_EDGE | \
GBL_c##clk(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA)
#define RM_RA_SPRITE(clk) AA_EN | CVG_DST_CLAMP | CVG_X_ALPHA | ALPHA_CVG_SEL | ZMODE_OPA | TEX_EDGE | GBL_c##clk(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_1MA)
#define G_RM_SPRITE G_RM_OPA_SURF
#define G_RM_SPRITE2 G_RM_OPA_SURF2
#define G_RM_RA_SPRITE RM_RA_SPRITE(1)
#define G_RM_RA_SPRITE2 RM_RA_SPRITE(2)
#define G_RM_AA_SPRITE G_RM_AA_TEX_TERR
#define G_RM_AA_SPRITE2 G_RM_AA_TEX_TERR2
#define G_RM_XLU_SPRITE G_RM_XLU_SURF
#define G_RM_XLU_SPRITE2 G_RM_XLU_SURF2
#define G_RM_AA_XLU_SPRITE G_RM_AA_XLU_SURF
#define G_RM_AA_XLU_SPRITE2 G_RM_AA_XLU_SURF2
#define G_RM_SPRITE G_RM_OPA_SURF
#define G_RM_SPRITE2 G_RM_OPA_SURF2
#define G_RM_RA_SPRITE RM_RA_SPRITE(1)
#define G_RM_RA_SPRITE2 RM_RA_SPRITE(2)
#define G_RM_AA_SPRITE G_RM_AA_TEX_TERR
#define G_RM_AA_SPRITE2 G_RM_AA_TEX_TERR2
#define G_RM_XLU_SPRITE G_RM_XLU_SURF
#define G_RM_XLU_SPRITE2 G_RM_XLU_SURF2
#define G_RM_AA_XLU_SPRITE G_RM_AA_XLU_SURF
#define G_RM_AA_XLU_SPRITE2 G_RM_AA_XLU_SURF2
/*===========================================================================*
* External functions
*===========================================================================*/
extern u64 gspS2DEX_fifoTextStart[], gspS2DEX_fifoTextEnd[];
extern u64 gspS2DEX_fifoDataStart[], gspS2DEX_fifoDataEnd[];
extern u64 gspS2DEX_fifo_dTextStart[], gspS2DEX_fifo_dTextEnd[];
extern u64 gspS2DEX_fifo_dDataStart[], gspS2DEX_fifo_dDataEnd[];
extern u64 gspS2DEX2_fifoTextStart[], gspS2DEX2_fifoTextEnd[];
extern u64 gspS2DEX2_fifoDataStart[], gspS2DEX2_fifoDataEnd[];
extern u64 gspS2DEX2_xbusTextStart[], gspS2DEX2_xbusTextEnd[];
extern u64 gspS2DEX2_xbusDataStart[], gspS2DEX2_xbusDataEnd[];
extern void guS2DInitBg(uObjBg *);
extern u64 gspS2DEX_fifoTextStart[], gspS2DEX_fifoTextEnd[];
extern u64 gspS2DEX_fifoDataStart[], gspS2DEX_fifoDataEnd[];
extern u64 gspS2DEX_fifo_dTextStart[], gspS2DEX_fifo_dTextEnd[];
extern u64 gspS2DEX_fifo_dDataStart[], gspS2DEX_fifo_dDataEnd[];
extern u64 gspS2DEX2_fifoTextStart[], gspS2DEX2_fifoTextEnd[];
extern u64 gspS2DEX2_fifoDataStart[], gspS2DEX2_fifoDataEnd[];
extern u64 gspS2DEX2_xbusTextStart[], gspS2DEX2_xbusTextEnd[];
extern u64 gspS2DEX2_xbusDataStart[], gspS2DEX2_xbusDataEnd[];
extern void guS2DInitBg(uObjBg*);
#ifdef F3DEX_GBI_2
# define guS2DEmuBgRect1Cyc guS2D2EmuBgRect1Cyc /*Wrapper*/
# define guS2DEmuSetScissor guS2D2EmuSetScissor /*Wrapper*/
extern void guS2D2EmuSetScissor(u32, u32, u32, u32, u8);
extern void guS2D2EmuBgRect1Cyc(Gfx **, uObjBg *);
#ifdef F3DEX_GBI_2
#define guS2DEmuBgRect1Cyc guS2D2EmuBgRect1Cyc /*Wrapper*/
#define guS2DEmuSetScissor guS2D2EmuSetScissor /*Wrapper*/
extern void guS2D2EmuSetScissor(u32, u32, u32, u32, u8);
extern void guS2D2EmuBgRect1Cyc(Gfx**, uObjBg*);
#else
extern void guS2DEmuSetScissor(u32, u32, u32, u32, u8);
extern void guS2DEmuBgRect1Cyc(Gfx **, uObjBg *);
extern void guS2DEmuSetScissor(u32, u32, u32, u32, u8);
extern void guS2DEmuBgRect1Cyc(Gfx**, uObjBg*);
#endif
#endif /* GS2DEX_H */

2
include/ultra64/gu.h
View File

@ -3,6 +3,6 @@
#define GU_PI 3.1415926
#define ROUND(x) (s32)(((x) >= 0.0) ? ((x) + 0.5) : ((x) - 0.5))
#define ROUND(x) (s32)(((x) >= 0.0) ? ((x) + 0.5) : ((x)-0.5))
#endif

24
include/ultra64/internal.h
View File

@ -3,19 +3,21 @@
#include "pi.h"
struct OSMgrArgs {
/* 0x00 */ u32 initialized;
/* 0x04 */ OSThread* mgrThread;
/* 0x08 */ OSMesgQueue* cmdQueue;
/* 0x0C */ OSMesgQueue* eventQueue;
/* 0x10 */ OSMesgQueue* acccessQueue;
/* 0x14 */ s32 (*piDmaCallback)(s32, u32, void*, size_t);
/* 0x18 */ s32 (*epiDmaCallback)(OSPiHandle*, s32, u32, void*, size_t);
struct OSMgrArgs
{
/* 0x00 */ u32 initialized;
/* 0x04 */ OSThread* mgrThread;
/* 0x08 */ OSMesgQueue* cmdQueue;
/* 0x0C */ OSMesgQueue* eventQueue;
/* 0x10 */ OSMesgQueue* acccessQueue;
/* 0x14 */ s32 (*piDmaCallback)(s32, u32, void*, size_t);
/* 0x18 */ s32 (*epiDmaCallback)(OSPiHandle*, s32, u32, void*, size_t);
}; // size = 0x1C
struct __OSEventState {
/* 0x00 */ OSMesgQueue* queue;
/* 0x04 */ OSMesg msg;
struct __OSEventState
{
/* 0x00 */ OSMesgQueue* queue;
/* 0x04 */ OSMesg msg;
}; // size = 0x08
extern OSMgrArgs __osPiDevMgr;

26
include/ultra64/mbi.h
View File

@ -8,13 +8,12 @@
*
*/
/*
* the SHIFT macros are used to build display list commands, inserting
* bit-fields into a 32-bit word. They take a value, a shift amount,
* bit-fields into a 32-bit word. They take a value, a shift amount,
* and a width.
*
* For the left shift, the lower bits of the value are masked,
* For the left shift, the lower bits of the value are masked,
* then shifted left.
*
* For the right shift, the value is shifted right, then the lower bits
@ -23,19 +22,16 @@
* (NOTE: _SHIFTL(v, 0, 32) won't work, just use an assignment)
*
*/
#define _SHIFTL(v, s, w) \
((u32) (((u32)(v) & ((0x01 << (w)) - 1)) << (s)))
#define _SHIFTR(v, s, w) \
((u32)(((u32)(v) >> (s)) & ((0x01 << (w)) - 1)))
#define _SHIFTL(v, s, w) ((u32)(((u32)(v) & ((0x01 << (w)) - 1)) << (s)))
#define _SHIFTR(v, s, w) ((u32)(((u32)(v) >> (s)) & ((0x01 << (w)) - 1)))
#define G_ON (1)
#define G_OFF (0)
#define G_ON (1)
#define G_OFF (0)
#include "gbi.h"
#include "abi.h"
#include "gbi.h"
#define NUM_SEGMENTS (16)
#define SEGMENT_OFFSET(a) ((u32)(a) & 0x00FFFFFF)
#define SEGMENT_NUMBER(a) (((u32)(a) << 4) >> 28)
#define SEGMENT_ADDR(num, off) (((num) << 24) + (off))
#define NUM_SEGMENTS (16)
#define SEGMENT_OFFSET(a) ((u32)(a)&0x00FFFFFF)
#define SEGMENT_NUMBER(a) (((u32)(a) << 4) >> 28)
#define SEGMENT_ADDR(num, off) (((num) << 24) + (off))

51
include/ultra64/message.h
View File

@ -3,37 +3,38 @@
#include "thread.h"
#define OS_MESG_NOBLOCK 0
#define OS_MESG_BLOCK 1
#define OS_MESG_NOBLOCK 0
#define OS_MESG_BLOCK 1
typedef void* OSMesg;
typedef u32 OSEvent;
#define OS_NUM_EVENTS 15
#define OS_NUM_EVENTS 15
#define OS_EVENT_SW1 0 /* CPU SW1 interrupt */
#define OS_EVENT_SW2 1 /* CPU SW2 interrupt */
#define OS_EVENT_CART 2 /* Cartridge interrupt: used by rmon */
#define OS_EVENT_COUNTER 3 /* Counter int: used by VI/Timer Mgr */
#define OS_EVENT_SP 4 /* SP task done interrupt */
#define OS_EVENT_SI 5 /* SI (controller) interrupt */
#define OS_EVENT_AI 6 /* AI interrupt */
#define OS_EVENT_VI 7 /* VI interrupt: used by VI/Timer Mgr */
#define OS_EVENT_PI 8 /* PI interrupt: used by PI Manager */
#define OS_EVENT_DP 9 /* DP full sync interrupt */
#define OS_EVENT_CPU_BREAK 10 /* CPU breakpoint: used by rmon */
#define OS_EVENT_SP_BREAK 11 /* SP breakpoint: used by rmon */
#define OS_EVENT_FAULT 12 /* CPU fault event: used by rmon */
#define OS_EVENT_THREADSTATUS 13 /* CPU thread status: used by rmon */
#define OS_EVENT_PRENMI 14 /* Pre NMI interrupt */
#define OS_EVENT_SW1 0 /* CPU SW1 interrupt */
#define OS_EVENT_SW2 1 /* CPU SW2 interrupt */
#define OS_EVENT_CART 2 /* Cartridge interrupt: used by rmon */
#define OS_EVENT_COUNTER 3 /* Counter int: used by VI/Timer Mgr */
#define OS_EVENT_SP 4 /* SP task done interrupt */
#define OS_EVENT_SI 5 /* SI (controller) interrupt */
#define OS_EVENT_AI 6 /* AI interrupt */
#define OS_EVENT_VI 7 /* VI interrupt: used by VI/Timer Mgr */
#define OS_EVENT_PI 8 /* PI interrupt: used by PI Manager */
#define OS_EVENT_DP 9 /* DP full sync interrupt */
#define OS_EVENT_CPU_BREAK 10 /* CPU breakpoint: used by rmon */
#define OS_EVENT_SP_BREAK 11 /* SP breakpoint: used by rmon */
#define OS_EVENT_FAULT 12 /* CPU fault event: used by rmon */
#define OS_EVENT_THREADSTATUS 13 /* CPU thread status: used by rmon */
#define OS_EVENT_PRENMI 14 /* Pre NMI interrupt */
struct OSMesgQueue {
/* 0x00 */ OSThread* mtqueue;
/* 0x04 */ OSThread* fullqueue;
/* 0x08 */ s32 validCount;
/* 0x0C */ s32 first;
/* 0x10 */ s32 msgCount;
/* 0x14 */ OSMesg* msg;
struct OSMesgQueue
{
/* 0x00 */ OSThread* mtqueue;
/* 0x04 */ OSThread* fullqueue;
/* 0x08 */ s32 validCount;
/* 0x0C */ s32 first;
/* 0x10 */ s32 msgCount;
/* 0x14 */ OSMesg* msg;
}; // size = 0x18
void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count);

4
include/ultra64/motor.h
View File

@ -4,10 +4,10 @@
#include "pfs.h"
#define MOTOR_START 1
#define MOTOR_STOP 0
#define MOTOR_STOP 0
#define osMotorStart(x) __osMotorAccess((x), MOTOR_START)
#define osMotorStop(x) __osMotorAccess((x), MOTOR_STOP)
#define osMotorStop(x) __osMotorAccess((x), MOTOR_STOP)
s32 __osMotorAccess(OSPfs* pfs, u32 vibrate);
s32 osMotorInit(OSMesgQueue* ctrlrqueue, OSPfs* pfs, s32 channel);

202
include/ultra64/pfs.h
View File

@ -4,134 +4,142 @@
#include "message.h"
/* File System size */
#define OS_PFS_VERSION 0x0200
#define OS_PFS_VERSION_HI (OS_PFS_VERSION >> 8)
#define OS_PFS_VERSION_LO (OS_PFS_VERSION & 255)
#define OS_PFS_VERSION 0x0200
#define OS_PFS_VERSION_HI (OS_PFS_VERSION >> 8)
#define OS_PFS_VERSION_LO (OS_PFS_VERSION & 255)
#define PFS_INODE_SIZE_PER_PAGE 128
#define PFS_FILE_NAME_LEN 16
#define PFS_FILE_EXT_LEN 4
#define BLOCKSIZE 32
#define PFS_ONE_PAGE 8
#define PFS_MAX_BANKS 62
#define PFS_FILE_NAME_LEN 16
#define PFS_FILE_EXT_LEN 4
#define BLOCKSIZE 32
#define PFS_ONE_PAGE 8
#define PFS_MAX_BANKS 62
/* File System flag */
#define PFS_READ 0
#define PFS_WRITE 1
#define PFS_CREATE 2
#define PFS_READ 0
#define PFS_WRITE 1
#define PFS_CREATE 2
/* File System status */
#define PFS_INITIALIZED 0x1
#define PFS_CORRUPTED 0x2
#define PFS_ID_BROKEN 0x4
#define PFS_MOTOR_INITIALIZED 0x8
#define PFS_GBPAK_INITIALIZED 0x10
#define PFS_INITIALIZED 0x1
#define PFS_CORRUPTED 0x2
#define PFS_ID_BROKEN 0x4
#define PFS_MOTOR_INITIALIZED 0x8
#define PFS_GBPAK_INITIALIZED 0x10
/* Definition for page usage */
#define PFS_EOF 1
#define PFS_PAGE_NOT_EXIST 2
#define PFS_PAGE_NOT_USED 3
#define PFS_EOF 1
#define PFS_PAGE_NOT_EXIST 2
#define PFS_PAGE_NOT_USED 3
/* File System error number */
#define PFS_ERR_NOPACK 1 /* no memory card is plugged or */
#define PFS_ERR_NEW_PACK 2 /* ram pack has been changed to a different one */
#define PFS_ERR_INCONSISTENT 3 /* need to run Pfschecker*/
#define PFS_ERR_CONTRFAIL CONT_OVERRUN_ERROR
#define PFS_ERR_INVALID 5 /* invalid parameter or file not exist*/
#define PFS_ERR_BAD_DATA 6 /* the data read from pack are bad*/
#define PFS_DATA_FULL 7 /* no free pages on ram pack*/
#define PFS_DIR_FULL 8 /* no free directories on ram pack*/
#define PFS_ERR_EXIST 9 /* file exists*/
#define PFS_ERR_ID_FATAL 10 /* dead ram pack */
#define PFS_ERR_DEVICE 11 /* wrong device type*/
#define PFS_ERR_NO_GBCART 12 /* no gb cartridge (64GB-PAK) */
#define PFS_ERR_NEW_GBCART 13 /* gb cartridge may be changed */
#define PFS_ERR_NOPACK 1 /* no memory card is plugged or */
#define PFS_ERR_NEW_PACK 2 /* ram pack has been changed to a different one */
#define PFS_ERR_INCONSISTENT 3 /* need to run Pfschecker*/
#define PFS_ERR_CONTRFAIL CONT_OVERRUN_ERROR
#define PFS_ERR_INVALID 5 /* invalid parameter or file not exist*/
#define PFS_ERR_BAD_DATA 6 /* the data read from pack are bad*/
#define PFS_DATA_FULL 7 /* no free pages on ram pack*/
#define PFS_DIR_FULL 8 /* no free directories on ram pack*/
#define PFS_ERR_EXIST 9 /* file exists*/
#define PFS_ERR_ID_FATAL 10 /* dead ram pack */
#define PFS_ERR_DEVICE 11 /* wrong device type*/
#define PFS_ERR_NO_GBCART 12 /* no gb cartridge (64GB-PAK) */
#define PFS_ERR_NEW_GBCART 13 /* gb cartridge may be changed */
/* Definition for bank */
#define PFS_ID_BANK_256K 0
#define PFS_ID_BANK_1M 4
#define PFS_BANKS_256K 1
#define PFS_ID_BANK_256K 0
#define PFS_ID_BANK_1M 4
#define PFS_BANKS_256K 1
#define PFS_WRITTEN 2
#define DEF_DIR_PAGES 2
#define PFS_WRITTEN 2
#define DEF_DIR_PAGES 2
#define PFS_ID_0AREA 1
#define PFS_ID_1AREA 3
#define PFS_ID_2AREA 4
#define PFS_ID_3AREA 6
#define PFS_LABEL_AREA 7
#define PFS_ID_PAGE PFS_ONE_PAGE * 0
#define PFS_ID_0AREA 1
#define PFS_ID_1AREA 3
#define PFS_ID_2AREA 4
#define PFS_ID_3AREA 6
#define PFS_LABEL_AREA 7
#define PFS_ID_PAGE PFS_ONE_PAGE * 0
#define PFS_BANK_LAPPED_BY 8 /* => u8 */
#define PFS_BANK_LAPPED_BY 8 /* => u8 */
#define PFS_SECTOR_PER_BANK 32
#define PFS_INODE_DIST_MAP (PFS_BANK_LAPPED_BY * PFS_SECTOR_PER_BANK)
#define PFS_SECTOR_SIZE (PFS_INODE_SIZE_PER_PAGE/PFS_SECTOR_PER_BANK)
#define PFS_INODE_DIST_MAP (PFS_BANK_LAPPED_BY * PFS_SECTOR_PER_BANK)
#define PFS_SECTOR_SIZE (PFS_INODE_SIZE_PER_PAGE / PFS_SECTOR_PER_BANK)
struct OSPfs {
/* 0x00 */ s32 status;
/* 0x04 */ OSMesgQueue* queue;
/* 0x08 */ s32 channel;
/* 0x0C */ u8 id[32];
/* 0x2C */ u8 label[32];
/* 0x4C */ s32 version;
/* 0x50 */ s32 dir_size;
/* 0x54 */ s32 inode_table; /* block location */
/* 0x58 */ s32 minode_table; /* mirrioring inode_table */
/* 0x5C */ s32 dir_table; /* block location */
/* 0x60 */ s32 inodeStartPage; /* page # */
/* 0x64 */ u8 banks;
/* 0x65 */ u8 activebank;
struct OSPfs
{
/* 0x00 */ s32 status;
/* 0x04 */ OSMesgQueue* queue;
/* 0x08 */ s32 channel;
/* 0x0C */ u8 id[32];
/* 0x2C */ u8 label[32];
/* 0x4C */ s32 version;
/* 0x50 */ s32 dir_size;
/* 0x54 */ s32 inode_table; /* block location */
/* 0x58 */ s32 minode_table; /* mirrioring inode_table */
/* 0x5C */ s32 dir_table; /* block location */
/* 0x60 */ s32 inodeStartPage; /* page # */
/* 0x64 */ u8 banks;
/* 0x65 */ u8 activebank;
}; // size = 0x68
struct OSPfsState {
/* 0x00 */ u32 file_size; /* bytes */
/* 0x04 */ u32 game_code;
/* 0x08 */ u16 company_code;
/* 0x0C */ char ext_name[4];
/* 0x10 */ char game_name[16];
struct OSPfsState
{
/* 0x00 */ u32 file_size; /* bytes */
/* 0x04 */ u32 game_code;
/* 0x08 */ u16 company_code;
/* 0x0C */ char ext_name[4];
/* 0x10 */ char game_name[16];
}; // size = 0x20
typedef union {
struct {
/* 0x00 */ u8 bank;
/* 0x01 */ u8 page;
} inode_t;
/* 0x00 */ u16 ipage;
typedef union
{
struct
{
/* 0x00 */ u8 bank;
/* 0x01 */ u8 page;
} inode_t;
/* 0x00 */ u16 ipage;
} __OSInodeUnit; // size = 0x02
struct __OSInode {
/* 0x00 */ __OSInodeUnit inodePage[128];
struct __OSInode
{
/* 0x00 */ __OSInodeUnit inodePage[128];
}; // size = 0x100
struct __OSDir {
/* 0x00 */ u32 game_code;
/* 0x04 */ u16 company_code;
/* 0x06 */ __OSInodeUnit start_page;
/* 0x08 */ u8 status;
/* 0x09 */ s8 reserved;
/* 0x0A */ u16 data_sum;
/* 0x0C */ u8 ext_name[PFS_FILE_EXT_LEN];
/* 0x10 */ u8 game_name[PFS_FILE_NAME_LEN];
struct __OSDir
{
/* 0x00 */ u32 game_code;
/* 0x04 */ u16 company_code;
/* 0x06 */ __OSInodeUnit start_page;
/* 0x08 */ u8 status;
/* 0x09 */ s8 reserved;
/* 0x0A */ u16 data_sum;
/* 0x0C */ u8 ext_name[PFS_FILE_EXT_LEN];
/* 0x10 */ u8 game_name[PFS_FILE_NAME_LEN];
}; // size = 0x20
struct __OSPackId {
/* 0x00 */ u32 repaired;
/* 0x04 */ u32 random;
/* 0x08 */ u64 serialMid;
/* 0x10 */ u64 serialLow;
/* 0x18 */ u16 deviceid;
/* 0x1A */ u8 banks;
/* 0x1B */ u8 version;
/* 0x1C */ u16 checksum;
/* 0x1E */ u16 invertedChecksum;
struct __OSPackId
{
/* 0x00 */ u32 repaired;
/* 0x04 */ u32 random;
/* 0x08 */ u64 serialMid;
/* 0x10 */ u64 serialLow;
/* 0x18 */ u16 deviceid;
/* 0x1A */ u8 banks;
/* 0x1B */ u8 version;
/* 0x1C */ u16 checksum;
/* 0x1E */ u16 invertedChecksum;
}; // size = 0x20
struct __OSInodeCache {
/* 0x000 */ __OSInode inode;
/* 0x100 */ u8 bank;
/* 0x101 */ u8 map[PFS_INODE_DIST_MAP];
struct __OSInodeCache
{
/* 0x000 */ __OSInode inode;
/* 0x100 */ u8 bank;
/* 0x101 */ u8 map[PFS_INODE_DIST_MAP];
}; // size = 0x202
#endif

124
include/ultra64/pi.h
View File

@ -3,81 +3,87 @@
#include "message.h"
struct __OSBlockInfo {
/* 0x00 */ u32 errStatus;
/* 0x04 */ void* dramAddr;
/* 0x08 */ void* C2Addr;
/* 0x0C */ u32 sectorSize;
/* 0x10 */ u32 C1ErrNum;
/* 0x14 */ u32 C1ErrSector[4];
struct __OSBlockInfo
{
/* 0x00 */ u32 errStatus;
/* 0x04 */ void* dramAddr;
/* 0x08 */ void* C2Addr;
/* 0x0C */ u32 sectorSize;
/* 0x10 */ u32 C1ErrNum;
/* 0x14 */ u32 C1ErrSector[4];
}; // size = 0x24
struct __OSTranxInfo {
/* 0x00 */ u32 cmdType;
/* 0x04 */ u16 transferMode;
/* 0x06 */ u16 blockNum;
/* 0x08 */ s32 sectorNum;
/* 0x0C */ Pointer devAddr;
/* 0x10 */ u32 bmCtlShadow;
/* 0x14 */ u32 seqCtlShadow;
/* 0x18 */ __OSBlockInfo block[2];
struct __OSTranxInfo
{
/* 0x00 */ u32 cmdType;
/* 0x04 */ u16 transferMode;
/* 0x06 */ u16 blockNum;
/* 0x08 */ s32 sectorNum;
/* 0x0C */ Pointer devAddr;
/* 0x10 */ u32 bmCtlShadow;
/* 0x14 */ u32 seqCtlShadow;
/* 0x18 */ __OSBlockInfo block[2];
}; // size = 0x60
struct OSPiHandle {
/* 0x00 */ struct OSPiHandle* next;
/* 0x04 */ u8 type;
/* 0x05 */ u8 latency;
/* 0x06 */ u8 pageSize;
/* 0x07 */ u8 relDuration;
/* 0x08 */ u8 pulse;
/* 0x09 */ u8 domain;
/* 0x0C */ Pointer baseAddress;
/* 0x10 */ u32 speed;
/* 0x14 */ __OSTranxInfo transferInfo;
struct OSPiHandle
{
/* 0x00 */ struct OSPiHandle* next;
/* 0x04 */ u8 type;
/* 0x05 */ u8 latency;
/* 0x06 */ u8 pageSize;
/* 0x07 */ u8 relDuration;
/* 0x08 */ u8 pulse;
/* 0x09 */ u8 domain;
/* 0x0C */ Pointer baseAddress;
/* 0x10 */ u32 speed;
/* 0x14 */ __OSTranxInfo transferInfo;
}; // size = 0x74
struct OSPiInfo {
/* 0x00 */ u8 type;
/* 0x04 */ Pointer address;
struct OSPiInfo
{
/* 0x00 */ u8 type;
/* 0x04 */ Pointer address;
}; // size = 0x08
struct OSIoMesgHdr {
/* 0x00 */ u16 type;
/* 0x02 */ u8 pri;
/* 0x03 */ u8 status;
/* 0x04 */ OSMesgQueue* retQueue;
struct OSIoMesgHdr
{
/* 0x00 */ u16 type;
/* 0x02 */ u8 pri;
/* 0x03 */ u8 status;
/* 0x04 */ OSMesgQueue* retQueue;
}; // size = 0x08
struct OSIoMesg {
/* 0x00 */ OSIoMesgHdr hdr;
struct OSIoMesg
{
/* 0x00 */ OSIoMesgHdr hdr;
/* 0x08 */ Pointer dramAddr;
/* 0x0C */ Pointer devAddr;
/* 0x10 */ size_t size;
/* 0x14 */ OSPiHandle* piHandle;
/* 0x0C */ Pointer devAddr;
/* 0x10 */ size_t size;
/* 0x14 */ OSPiHandle* piHandle;
}; // size = 0x18
#define OS_READ 0 // device -> RDRAM
#define OS_WRITE 1 // device <- RDRAM
#define OS_OTHERS 2 // for disk drive transfers
#define OS_READ 0 // device -> RDRAM
#define OS_WRITE 1 // device <- RDRAM
#define OS_OTHERS 2 // for disk drive transfers
#define PI_DOMAIN1 0
#define PI_DOMAIN2 1
#define PI_DOMAIN1 0
#define PI_DOMAIN2 1
#define OS_MESG_TYPE_LOOPBACK 10
#define OS_MESG_TYPE_DMAREAD 11
#define OS_MESG_TYPE_DMAWRITE 12
#define OS_MESG_TYPE_VRETRACE 13
#define OS_MESG_TYPE_COUNTER 14
#define OS_MESG_TYPE_EDMAREAD 15
#define OS_MESG_TYPE_EDMAWRITE 16
#define OS_MESG_TYPE_LOOPBACK 10
#define OS_MESG_TYPE_DMAREAD 11
#define OS_MESG_TYPE_DMAWRITE 12
#define OS_MESG_TYPE_VRETRACE 13
#define OS_MESG_TYPE_COUNTER 14
#define OS_MESG_TYPE_EDMAREAD 15
#define OS_MESG_TYPE_EDMAWRITE 16
#define OS_MESG_PRI_NORMAL 0
#define OS_MESG_PRI_HIGH 1
#define OS_MESG_PRI_NORMAL 0
#define OS_MESG_PRI_HIGH 1
#define DEVICE_TYPE_CART 0 /* ROM cartridge */
#define DEVICE_TYPE_BULK 1 /* ROM bulk */
#define DEVICE_TYPE_64DD 2 /* 64 Disk Drive */
#define DEVICE_TYPE_SRAM 3 /* SRAM */
#define DEVICE_TYPE_INIT 7 /* initial value */
#define DEVICE_TYPE_CART 0 /* ROM cartridge */
#define DEVICE_TYPE_BULK 1 /* ROM bulk */
#define DEVICE_TYPE_64DD 2 /* 64 Disk Drive */
#define DEVICE_TYPE_SRAM 3 /* SRAM */
#define DEVICE_TYPE_INIT 7 /* initial value */
#endif

33
include/ultra64/printf.h
View File

@ -5,22 +5,23 @@
struct _Pft
{
/* 0x0 */ union {
/* 0x0 */ s64 ll;
/* 0x0 */ f64 ld;
} v;
/* 0x8 */ char* s;
/* 0xC */ s32 n0;
/* 0x10 */ s32 nz0;
/* 0x14 */ s32 n1;
/* 0x18 */ s32 nz1;
/* 0x1C */ s32 n2;
/* 0x20 */ s32 nz2;
/* 0x24 */ s32 prec;
/* 0x28 */ s32 width;
/* 0x2C */ u32 nchar;
/* 0x30 */ u32 flags;
/* 0x34 */ u8 qual;
/* 0x0 */ union
{
/* 0x0 */ s64 ll;
/* 0x0 */ f64 ld;
} v;
/* 0x8 */ char* s;
/* 0xC */ s32 n0;
/* 0x10 */ s32 nz0;
/* 0x14 */ s32 n1;
/* 0x18 */ s32 nz1;
/* 0x1C */ s32 n2;
/* 0x20 */ s32 nz2;
/* 0x24 */ s32 prec;
/* 0x28 */ s32 width;
/* 0x2C */ u32 nchar;
/* 0x30 */ u32 flags;
/* 0x34 */ u8 qual;
}; // size = 0x38
typedef void* (*PrintCallback)(void*, const char*, u32);

548
include/ultra64/r4300.h
View File

@ -11,290 +11,290 @@
#endif
// Segment base addresses and sizes
#define KUBASE 0
#define KUSIZE 0x80000000
#define K0BASE 0x80000000
#define K0SIZE 0x20000000
#define K1BASE 0xA0000000
#define K1SIZE 0x20000000
#define K2BASE 0xC0000000
#define K2SIZE 0x20000000
#define KUBASE 0
#define KUSIZE 0x80000000
#define K0BASE 0x80000000
#define K0SIZE 0x20000000
#define K1BASE 0xA0000000
#define K1SIZE 0x20000000
#define K2BASE 0xC0000000
#define K2SIZE 0x20000000
// Exception vectors
#define SIZE_EXCVEC 0x80 // Size of an exc. vec
#define UT_VEC K0BASE // utlbmiss vector
#define R_VEC (K1BASE + 0x1FC00000) // reset vector
#define XUT_VEC (K0BASE + 0x80) // extended address tlbmiss
#define ECC_VEC (K0BASE + 0x100) // Ecc exception vector
#define E_VEC (K0BASE + 0x180) // Gen. exception vector
#define SIZE_EXCVEC 0x80 // Size of an exc. vec
#define UT_VEC K0BASE // utlbmiss vector
#define R_VEC (K1BASE + 0x1FC00000) // reset vector
#define XUT_VEC (K0BASE + 0x80) // extended address tlbmiss
#define ECC_VEC (K0BASE + 0x100) // Ecc exception vector
#define E_VEC (K0BASE + 0x180) // Gen. exception vector
// Address conversion macros
#define K0_TO_K1(x) (U32(x) | 0xA0000000) // kseg0 to kseg1
#define K1_TO_K0(x) (U32(x) & 0x9FFFFFFF) // kseg1 to kseg0
#define K0_TO_PHYS(x) (U32(x) & 0x1FFFFFFF) // kseg0 to physical
#define K1_TO_PHYS(x) (U32(x) & 0x1FFFFFFF) // kseg1 to physical
#define KDM_TO_PHYS(x) (U32(x) & 0x1FFFFFFF) // direct mapped to physical
#define PHYS_TO_K0(x) (U32(x) | 0x80000000) // physical to kseg0
#define PHYS_TO_K1(x) (U32(x) | 0xA0000000) // physical to kseg1
#define K0_TO_K1(x) (U32(x) | 0xA0000000) // kseg0 to kseg1
#define K1_TO_K0(x) (U32(x) & 0x9FFFFFFF) // kseg1 to kseg0
#define K0_TO_PHYS(x) (U32(x) & 0x1FFFFFFF) // kseg0 to physical
#define K1_TO_PHYS(x) (U32(x) & 0x1FFFFFFF) // kseg1 to physical
#define KDM_TO_PHYS(x) (U32(x) & 0x1FFFFFFF) // direct mapped to physical
#define PHYS_TO_K0(x) (U32(x) | 0x80000000) // physical to kseg0
#define PHYS_TO_K1(x) (U32(x) | 0xA0000000) // physical to kseg1
// Address predicates
#define IS_KSEG0(x) (U32(x) >= K0BASE && U32(x) < K1BASE)
#define IS_KSEG1(x) (U32(x) >= K1BASE && U32(x) < K2BASE)
#define IS_KSEGDM(x) (U32(x) >= K0BASE && U32(x) < K2BASE)
#define IS_KSEG2(x) (U32(x) >= K2BASE && U32(x) < KPTE_SHDUBASE)
#define IS_KPTESEG(x) (U32(x) >= KPTE_SHDUBASE)
#define IS_KUSEG(x) (U32(x) < K0BASE)
#define IS_KSEG0(x) (U32(x) >= K0BASE && U32(x) < K1BASE)
#define IS_KSEG1(x) (U32(x) >= K1BASE && U32(x) < K2BASE)
#define IS_KSEGDM(x) (U32(x) >= K0BASE && U32(x) < K2BASE)
#define IS_KSEG2(x) (U32(x) >= K2BASE && U32(x) < KPTE_SHDUBASE)
#define IS_KPTESEG(x) (U32(x) >= KPTE_SHDUBASE)
#define IS_KUSEG(x) (U32(x) < K0BASE)
// TLB size constants
#define NTLBENTRIES 31 /* entry 31 is reserved by rdb */
#define NTLBENTRIES 31 /* entry 31 is reserved by rdb */
#define TLBHI_VPN2MASK 0xFFFFE000
#define TLBHI_VPN2SHIFT 13
#define TLBHI_PIDMASK 0xFF
#define TLBHI_PIDSHIFT 0
#define TLBHI_NPID 255 // 255 to fit in 8 bits
#define TLBHI_VPN2MASK 0xFFFFE000
#define TLBHI_VPN2SHIFT 13
#define TLBHI_PIDMASK 0xFF
#define TLBHI_PIDSHIFT 0
#define TLBHI_NPID 255 // 255 to fit in 8 bits
#define TLBLO_PFNMASK 0x3FFFFFC0
#define TLBLO_PFNSHIFT 6
#define TLBLO_CACHMASK 0x38 // cache coherency algorithm
#define TLBLO_CACHSHIFT 3
#define TLBLO_UNCACHED 0x10 // not cached
#define TLBLO_NONCOHRNT 0x18 // Cacheable non-coherent
#define TLBLO_EXLWR 0x28 // Exclusive write
#define TLBLO_D 0x4 // writeable
#define TLBLO_V 0x2 // valid bit
#define TLBLO_G 0x1 // global access bit
#define TLBLO_PFNMASK 0x3FFFFFC0
#define TLBLO_PFNSHIFT 6
#define TLBLO_CACHMASK 0x38 // cache coherency algorithm
#define TLBLO_CACHSHIFT 3
#define TLBLO_UNCACHED 0x10 // not cached
#define TLBLO_NONCOHRNT 0x18 // Cacheable non-coherent
#define TLBLO_EXLWR 0x28 // Exclusive write
#define TLBLO_D 0x4 // writeable
#define TLBLO_V 0x2 // valid bit
#define TLBLO_G 0x1 // global access bit
#define TLBINX_PROBE 0x80000000
#define TLBINX_INXMASK 0x3F
#define TLBINX_INXSHIFT 0
#define TLBINX_PROBE 0x80000000
#define TLBINX_INXMASK 0x3F
#define TLBINX_INXSHIFT 0
#define TLBRAND_RANDMASK 0x3F
#define TLBRAND_RANDSHIFT 0
#define TLBRAND_RANDMASK 0x3F
#define TLBRAND_RANDSHIFT 0
#define TLBWIRED_WIREDMASK 0x3F
#define TLBWIRED_WIREDMASK 0x3F
#define TLBCTXT_BASEMASK 0xFF800000
#define TLBCTXT_BASESHIFT 23
#define TLBCTXT_BASEBITS 9
#define TLBCTXT_BASEMASK 0xFF800000
#define TLBCTXT_BASESHIFT 23
#define TLBCTXT_BASEBITS 9
#define TLBCTXT_VPNMASK 0x7FFFF0
#define TLBCTXT_VPNSHIFT 4
#define TLBCTXT_VPNMASK 0x7FFFF0
#define TLBCTXT_VPNSHIFT 4
#define TLBPGMASK_4K 0x0
#define TLBPGMASK_16K 0x6000
#define TLBPGMASK_64K 0x1E000
#define TLBPGMASK_4K 0x0
#define TLBPGMASK_16K 0x6000
#define TLBPGMASK_64K 0x1E000
/*
* Status register
*/
#define SR_CUMASK 0xF0000000 // coproc usable bits
#define SR_CUMASK 0xF0000000 // coproc usable bits
#define SR_CU3 0x80000000 // Coprocessor 3 usable
#define SR_CU2 0x40000000 // Coprocessor 2 usable
#define SR_CU1 0x20000000 // Coprocessor 1 usable
#define SR_CU0 0x10000000 // Coprocessor 0 usable
#define SR_RP 0x08000000 // Reduced power (quarter speed)
#define SR_FR 0x04000000 // MIPS III FP register mode
#define SR_RE 0x02000000 // Reverse endian
#define SR_ITS 0x01000000 // Instruction trace support
#define SR_BEV 0x00400000 // Use boot exception vectors
#define SR_TS 0x00200000 // TLB shutdown
#define SR_SR 0x00100000 // Soft reset occured
#define SR_CH 0x00040000 // Cache hit for last 'cache' op
#define SR_CE 0x00020000 // Create ECC
#define SR_DE 0x00010000 // ECC of parity does not cause error
#define SR_CU3 0x80000000 // Coprocessor 3 usable
#define SR_CU2 0x40000000 // Coprocessor 2 usable
#define SR_CU1 0x20000000 // Coprocessor 1 usable
#define SR_CU0 0x10000000 // Coprocessor 0 usable
#define SR_RP 0x08000000 // Reduced power (quarter speed)
#define SR_FR 0x04000000 // MIPS III FP register mode
#define SR_RE 0x02000000 // Reverse endian
#define SR_ITS 0x01000000 // Instruction trace support
#define SR_BEV 0x00400000 // Use boot exception vectors
#define SR_TS 0x00200000 // TLB shutdown
#define SR_SR 0x00100000 // Soft reset occured
#define SR_CH 0x00040000 // Cache hit for last 'cache' op
#define SR_CE 0x00020000 // Create ECC
#define SR_DE 0x00010000 // ECC of parity does not cause error
// Interrupt enable bits
// (NOTE: bits set to 1 enable the corresponding level interrupt)
#define SR_IMASK 0x0000FF00 // Interrupt mask
#define SR_IMASK8 0x00000000 // mask level 8
#define SR_IMASK7 0x00008000 // mask level 7
#define SR_IMASK6 0x0000C000 // mask level 6
#define SR_IMASK5 0x0000E000 // mask level 5
#define SR_IMASK4 0x0000F000 // mask level 4
#define SR_IMASK3 0x0000F800 // mask level 3
#define SR_IMASK2 0x0000FC00 // mask level 2
#define SR_IMASK1 0x0000FE00 // mask level 1
#define SR_IMASK0 0x0000FF00 // mask level 0
#define SR_IMASK 0x0000FF00 // Interrupt mask
#define SR_IMASK8 0x00000000 // mask level 8
#define SR_IMASK7 0x00008000 // mask level 7
#define SR_IMASK6 0x0000C000 // mask level 6
#define SR_IMASK5 0x0000E000 // mask level 5
#define SR_IMASK4 0x0000F000 // mask level 4
#define SR_IMASK3 0x0000F800 // mask level 3
#define SR_IMASK2 0x0000FC00 // mask level 2
#define SR_IMASK1 0x0000FE00 // mask level 1
#define SR_IMASK0 0x0000FF00 // mask level 0
#define SR_IBIT8 0x00008000 // bit level 8
#define SR_IBIT7 0x00004000 // bit level 7
#define SR_IBIT6 0x00002000 // bit level 6
#define SR_IBIT5 0x00001000 // bit level 5
#define SR_IBIT4 0x00000800 // bit level 4
#define SR_IBIT3 0x00000400 // bit level 3
#define SR_IBIT2 0x00000200 // bit level 2
#define SR_IBIT1 0x00000100 // bit level 1
#define SR_IBIT8 0x00008000 // bit level 8
#define SR_IBIT7 0x00004000 // bit level 7
#define SR_IBIT6 0x00002000 // bit level 6
#define SR_IBIT5 0x00001000 // bit level 5
#define SR_IBIT4 0x00000800 // bit level 4
#define SR_IBIT3 0x00000400 // bit level 3
#define SR_IBIT2 0x00000200 // bit level 2
#define SR_IBIT1 0x00000100 // bit level 1
#define SR_IMASKSHIFT 8
#define SR_IMASKSHIFT 8
#define SR_KX 0x00000080 // extended-addr TLB vec in kernel
#define SR_SX 0x00000040 // xtended-addr TLB vec supervisor
#define SR_UX 0x00000020 // xtended-addr TLB vec in user mode
#define SR_KSU_MASK 0x00000018 // mode mask
#define SR_KSU_USR 0x00000010 // user mode
#define SR_KSU_SUP 0x00000008 // supervisor mode
#define SR_KSU_KER 0x00000000 // kernel mode
#define SR_ERL 0x00000004 // Error level, 1=>cache error
#define SR_EXL 0x00000002 // Exception level, 1=>exception
#define SR_IE 0x00000001 // interrupt enable, 1=>enable
#define SR_KX 0x00000080 // extended-addr TLB vec in kernel
#define SR_SX 0x00000040 // xtended-addr TLB vec supervisor
#define SR_UX 0x00000020 // xtended-addr TLB vec in user mode
#define SR_KSU_MASK 0x00000018 // mode mask
#define SR_KSU_USR 0x00000010 // user mode
#define SR_KSU_SUP 0x00000008 // supervisor mode
#define SR_KSU_KER 0x00000000 // kernel mode
#define SR_ERL 0x00000004 // Error level, 1=>cache error
#define SR_EXL 0x00000002 // Exception level, 1=>exception
#define SR_IE 0x00000001 // interrupt enable, 1=>enable
// Cause Register
#define CAUSE_BD 0x80000000 // Branch delay slot
#define CAUSE_CEMASK 0x30000000 // coprocessor error
#define CAUSE_CESHIFT 28
#define CAUSE_BD 0x80000000 // Branch delay slot
#define CAUSE_CEMASK 0x30000000 // coprocessor error
#define CAUSE_CESHIFT 28
// Interrupt pending bits
#define CAUSE_IP8 0x00008000 // External level 8 pending - COMPARE
#define CAUSE_IP7 0x00004000 // External level 7 pending - INT4
#define CAUSE_IP6 0x00002000 // External level 6 pending - INT3
#define CAUSE_IP5 0x00001000 // External level 5 pending - INT2
#define CAUSE_IP4 0x00000800 // External level 4 pending - INT1
#define CAUSE_IP3 0x00000400 // External level 3 pending - INT0
#define CAUSE_SW2 0x00000200 // Software level 2 pending
#define CAUSE_SW1 0x00000100 // Software level 1 pending
#define CAUSE_IP8 0x00008000 // External level 8 pending - COMPARE
#define CAUSE_IP7 0x00004000 // External level 7 pending - INT4
#define CAUSE_IP6 0x00002000 // External level 6 pending - INT3
#define CAUSE_IP5 0x00001000 // External level 5 pending - INT2
#define CAUSE_IP4 0x00000800 // External level 4 pending - INT1
#define CAUSE_IP3 0x00000400 // External level 3 pending - INT0
#define CAUSE_SW2 0x00000200 // Software level 2 pending
#define CAUSE_SW1 0x00000100 // Software level 1 pending
#define CAUSE_IPMASK 0x0000FF00 // Pending interrupt mask
#define CAUSE_IPSHIFT 8
#define CAUSE_IPMASK 0x0000FF00 // Pending interrupt mask
#define CAUSE_IPSHIFT 8
#define CAUSE_EXCMASK 0x0000007C // Cause code bits
#define CAUSE_EXCSHIFT 2
#define CAUSE_EXCMASK 0x0000007C // Cause code bits
#define CAUSE_EXCSHIFT 2
// Cause register exception codes
#define EXC_CODE(x) ((x) << 2)
// Hardware exception codes
#define EXC_INT EXC_CODE(0) // interrupt
#define EXC_MOD EXC_CODE(1) // TLB mod
#define EXC_RMISS EXC_CODE(2) // Read TLB Miss
#define EXC_WMISS EXC_CODE(3) // Write TLB Miss
#define EXC_RADE EXC_CODE(4) // Read Address Error
#define EXC_WADE EXC_CODE(5) // Write Address Error
#define EXC_IBE EXC_CODE(6) // Instruction Bus Error
#define EXC_DBE EXC_CODE(7) // Data Bus Error
#define EXC_SYSCALL EXC_CODE(8) // SYSCALL
#define EXC_BREAK EXC_CODE(9) // BREAKpoint
#define EXC_II EXC_CODE(10) // Illegal Instruction
#define EXC_CPU EXC_CODE(11) // CoProcessor Unusable
#define EXC_OV EXC_CODE(12) // OVerflow
#define EXC_TRAP EXC_CODE(13) // Trap exception
#define EXC_VCEI EXC_CODE(14) // Virt. Coherency on Inst. fetch
#define EXC_FPE EXC_CODE(15) // Floating Point Exception
#define EXC_WATCH EXC_CODE(23) // Watchpoint reference
#define EXC_VCED EXC_CODE(31) // Virt. Coherency on data read
#define EXC_INT EXC_CODE(0) // interrupt
#define EXC_MOD EXC_CODE(1) // TLB mod
#define EXC_RMISS EXC_CODE(2) // Read TLB Miss
#define EXC_WMISS EXC_CODE(3) // Write TLB Miss
#define EXC_RADE EXC_CODE(4) // Read Address Error
#define EXC_WADE EXC_CODE(5) // Write Address Error
#define EXC_IBE EXC_CODE(6) // Instruction Bus Error
#define EXC_DBE EXC_CODE(7) // Data Bus Error
#define EXC_SYSCALL EXC_CODE(8) // SYSCALL
#define EXC_BREAK EXC_CODE(9) // BREAKpoint
#define EXC_II EXC_CODE(10) // Illegal Instruction
#define EXC_CPU EXC_CODE(11) // CoProcessor Unusable
#define EXC_OV EXC_CODE(12) // OVerflow
#define EXC_TRAP EXC_CODE(13) // Trap exception
#define EXC_VCEI EXC_CODE(14) // Virt. Coherency on Inst. fetch
#define EXC_FPE EXC_CODE(15) // Floating Point Exception
#define EXC_WATCH EXC_CODE(23) // Watchpoint reference
#define EXC_VCED EXC_CODE(31) // Virt. Coherency on data read
// C0_PRID Defines
#define C0_IMPMASK 0xFF00
#define C0_IMPSHIFT 8
#define C0_REVMASK 0xFF
#define C0_MAJREVMASK 0xF0
#define C0_MAJREVSHIFT 4
#define C0_MINREVMASK 0xF
#define C0_IMPMASK 0xFF00
#define C0_IMPSHIFT 8
#define C0_REVMASK 0xFF
#define C0_MAJREVMASK 0xF0
#define C0_MAJREVSHIFT 4
#define C0_MINREVMASK 0xF
// Coprocessor 0 operations
#define C0_READI 0x1 // read ITLB entry addressed by C0_INDEX
#define C0_WRITEI 0x2 // write ITLB entry addressed by C0_INDEX
#define C0_WRITER 0x6 // write ITLB entry addressed by C0_RAND
#define C0_PROBE 0x8 // probe for ITLB entry addressed by TLBHI
#define C0_RFE 0x10 // restore for exception
#define C0_READI 0x1 // read ITLB entry addressed by C0_INDEX
#define C0_WRITEI 0x2 // write ITLB entry addressed by C0_INDEX
#define C0_WRITER 0x6 // write ITLB entry addressed by C0_RAND
#define C0_PROBE 0x8 // probe for ITLB entry addressed by TLBHI
#define C0_RFE 0x10 // restore for exception
// 'cache' instruction definitions
// Target cache
#define CACH_PI 0x0 // specifies primary inst. cache
#define CACH_PD 0x1 // primary data cache
#define CACH_SI 0x2 // secondary instruction cache
#define CACH_SD 0x3 // secondary data cache
#define CACH_PI 0x0 // specifies primary inst. cache
#define CACH_PD 0x1 // primary data cache
#define CACH_SI 0x2 // secondary instruction cache
#define CACH_SD 0x3 // secondary data cache
// Cache operations
#define C_IINV 0x0 // index invalidate (inst, 2nd inst)
#define C_IWBINV 0x0 // index writeback inval (d, sd)
#define C_ILT 0x4 // index load tag (all)
#define C_IST 0x8 // index store tag (all)
#define C_CDX 0xC // create dirty exclusive (d, sd)
#define C_HINV 0x10 // hit invalidate (all)
#define C_HWBINV 0x14 // hit writeback inv. (d, sd)
#define C_FILL 0x14 // fill (i)
#define C_HWB 0x18 // hit writeback (i, d, sd)
#define C_HSV 0x1C // hit set virt. (si, sd)
#define C_IINV 0x0 // index invalidate (inst, 2nd inst)
#define C_IWBINV 0x0 // index writeback inval (d, sd)
#define C_ILT 0x4 // index load tag (all)
#define C_IST 0x8 // index store tag (all)
#define C_CDX 0xC // create dirty exclusive (d, sd)
#define C_HINV 0x10 // hit invalidate (all)
#define C_HWBINV 0x14 // hit writeback inv. (d, sd)
#define C_FILL 0x14 // fill (i)
#define C_HWB 0x18 // hit writeback (i, d, sd)
#define C_HSV 0x1C // hit set virt. (si, sd)
// Cache size definitions
#define ICACHE_SIZE 0x4000 // 16K
#define ICACHE_LINESIZE 32 // 8 words
#define ICACHE_LINEMASK (ICACHE_LINESIZE - 1)
#define ICACHE_SIZE 0x4000 // 16K
#define ICACHE_LINESIZE 32 // 8 words
#define ICACHE_LINEMASK (ICACHE_LINESIZE - 1)
#define DCACHE_SIZE 0x2000 // 8K
#define DCACHE_LINESIZE 16 // 4 words
#define DCACHE_LINEMASK (DCACHE_LINESIZE - 1)
#define DCACHE_SIZE 0x2000 // 8K
#define DCACHE_LINESIZE 16 // 4 words
#define DCACHE_LINEMASK (DCACHE_LINESIZE - 1)
// C0_CONFIG register definitions
#define CONFIG_CM 0x80000000 // 1 == Master-Checker enabled
#define CONFIG_EC 0x70000000 // System Clock ratio
#define CONFIG_EC_1_1 0x6 // System Clock ratio 1 :1
#define CONFIG_EC_3_2 0x7 // System Clock ratio 1.5 :1
#define CONFIG_EC_2_1 0x0 // System Clock ratio 2 :1
#define CONFIG_EC_3_1 0x1 // System Clock ratio 3 :1
#define CONFIG_EP 0x0F000000 // Transmit Data Pattern
#define CONFIG_SB 0x00C00000 // Secondary cache block size
#define CONFIG_CM 0x80000000 // 1 == Master-Checker enabled
#define CONFIG_EC 0x70000000 // System Clock ratio
#define CONFIG_EC_1_1 0x6 // System Clock ratio 1 :1
#define CONFIG_EC_3_2 0x7 // System Clock ratio 1.5 :1
#define CONFIG_EC_2_1 0x0 // System Clock ratio 2 :1
#define CONFIG_EC_3_1 0x1 // System Clock ratio 3 :1
#define CONFIG_EP 0x0F000000 // Transmit Data Pattern
#define CONFIG_SB 0x00C00000 // Secondary cache block size
#define CONFIG_SS 0x00200000 // Split scache: 0 == I&D combined
#define CONFIG_SW 0x00100000 // scache port: 0==128, 1==64
#define CONFIG_EW 0x000C0000 // System Port width: 0==64, 1==32
#define CONFIG_SC 0x00020000 // 0 -> 2nd cache present
#define CONFIG_SM 0x00010000 // 0 -> Dirty Shared Coherency enable
#define CONFIG_BE 0x00008000 // Endian-ness: 1 --> BE
#define CONFIG_EM 0x00004000 // 1 -> ECC mode, 0 -> parity
#define CONFIG_EB 0x00002000 // Block order:1->sequent,0->subblock
#define CONFIG_SS 0x00200000 // Split scache: 0 == I&D combined
#define CONFIG_SW 0x00100000 // scache port: 0==128, 1==64
#define CONFIG_EW 0x000C0000 // System Port width: 0==64, 1==32
#define CONFIG_SC 0x00020000 // 0 -> 2nd cache present
#define CONFIG_SM 0x00010000 // 0 -> Dirty Shared Coherency enable
#define CONFIG_BE 0x00008000 // Endian-ness: 1 --> BE
#define CONFIG_EM 0x00004000 // 1 -> ECC mode, 0 -> parity
#define CONFIG_EB 0x00002000 // Block order:1->sequent,0->subblock
#define CONFIG_IC 0x00000E00 // Primary Icache size
#define CONFIG_DC 0x000001C0 // Primary Dcache size
#define CONFIG_IB 0x00000020 // Icache block size
#define CONFIG_DB 0x00000010 // Dcache block size
#define CONFIG_CU 0x00000008 // Update on Store-conditional
#define CONFIG_K0 0x00000007 // K0SEG Coherency algorithm
#define CONFIG_IC 0x00000E00 // Primary Icache size
#define CONFIG_DC 0x000001C0 // Primary Dcache size
#define CONFIG_IB 0x00000020 // Icache block size
#define CONFIG_DB 0x00000010 // Dcache block size
#define CONFIG_CU 0x00000008 // Update on Store-conditional
#define CONFIG_K0 0x00000007 // K0SEG Coherency algorithm
#define CONFIG_UNCACHED 0x00000002 // K0 is uncached
#define CONFIG_NONCOHRNT 0x00000003
#define CONFIG_UNCACHED 0x00000002 // K0 is uncached
#define CONFIG_NONCOHRNT 0x00000003
#define CONFIG_COHRNT_EXLWR 0x00000005
#define CONFIG_SB_SHFT 22 // shift SB to bit position 0
#define CONFIG_IC_SHFT 9 // shift IC to bit position 0
#define CONFIG_DC_SHFT 6 // shift DC to bit position 0
#define CONFIG_BE_SHFT 15 // shift BE to bit position 0
#define CONFIG_SB_SHFT 22 // shift SB to bit position 0
#define CONFIG_IC_SHFT 9 // shift IC to bit position 0
#define CONFIG_DC_SHFT 6 // shift DC to bit position 0
#define CONFIG_BE_SHFT 15 // shift BE to bit position 0
// C0_TAGLO definitions for setting/getting cache states and physaddr bits
#define SADDRMASK 0xFFFFE000 // 31..13 -> scache paddr bits 35..17
#define SVINDEXMASK 0x00000380 // 9..7: prim virt index bits 14..12
#define SSTATEMASK 0x00001C00 // bits 12..10 hold scache line state
#define SINVALID 0x00000000 // invalid --> 000 == state 0
#define SCLEANEXCL 0x00001000 // clean exclusive --> 100 == state 4
#define SDIRTYEXCL 0x00001400 // dirty exclusive --> 101 == state 5
#define SECC_MASK 0x0000007F // low 7 bits are ecc for the tag
#define SADDR_SHIFT 4 // shift STagLo (31..13) to 35..17
#define SADDRMASK 0xFFFFE000 // 31..13 -> scache paddr bits 35..17
#define SVINDEXMASK 0x00000380 // 9..7: prim virt index bits 14..12
#define SSTATEMASK 0x00001C00 // bits 12..10 hold scache line state
#define SINVALID 0x00000000 // invalid --> 000 == state 0
#define SCLEANEXCL 0x00001000 // clean exclusive --> 100 == state 4
#define SDIRTYEXCL 0x00001400 // dirty exclusive --> 101 == state 5
#define SECC_MASK 0x0000007F // low 7 bits are ecc for the tag
#define SADDR_SHIFT 4 // shift STagLo (31..13) to 35..17
#define PADDRMASK 0xFFFFFF00 // PTagLo31..8->prim paddr bits35..12
#define PADDR_SHIFT 4 // roll bits 35..12 down to 31..8
#define PSTATEMASK 0x00C0 // bits 7..6 hold primary line state
#define PINVALID 0x0000 // invalid --> 000 == state 0
#define PCLEANEXCL 0x0080 // clean exclusive --> 10 == state 2
#define PDIRTYEXCL 0x00C0 // dirty exclusive --> 11 == state 3
#define PPARITY_MASK 0x0001 // low bit is parity bit (even).
#define PADDRMASK 0xFFFFFF00 // PTagLo31..8->prim paddr bits35..12
#define PADDR_SHIFT 4 // roll bits 35..12 down to 31..8
#define PSTATEMASK 0x00C0 // bits 7..6 hold primary line state
#define PINVALID 0x0000 // invalid --> 000 == state 0
#define PCLEANEXCL 0x0080 // clean exclusive --> 10 == state 2
#define PDIRTYEXCL 0x00C0 // dirty exclusive --> 11 == state 3
#define PPARITY_MASK 0x0001 // low bit is parity bit (even).
// C0_CACHE_ERR definitions.
#define CACHERR_ER 0x80000000 // 0: inst ref, 1: data ref
#define CACHERR_EC 0x40000000 // 0: primary, 1: secondary
#define CACHERR_ED 0x20000000 // 1: data error
#define CACHERR_ET 0x10000000 // 1: tag error
#define CACHERR_ES 0x08000000 // 1: external ref, e.g. snoo
#define CACHERR_EE 0x04000000 // error on SysAD bus
#define CACHERR_EB 0x02000000 // complicated, see spec.
#define CACHERR_EI 0x01000000 // complicated, see spec.
#define CACHERR_SIDX_MASK 0x003FFFF8 // secondary cache index
#define CACHERR_PIDX_MASK 0x00000007 // primary cache index
#define CACHERR_PIDX_SHIFT 12 // bits 2..0 are paddr14..12
#define CACHERR_ER 0x80000000 // 0: inst ref, 1: data ref
#define CACHERR_EC 0x40000000 // 0: primary, 1: secondary
#define CACHERR_ED 0x20000000 // 1: data error
#define CACHERR_ET 0x10000000 // 1: tag error
#define CACHERR_ES 0x08000000 // 1: external ref, e.g. snoo
#define CACHERR_EE 0x04000000 // error on SysAD bus
#define CACHERR_EB 0x02000000 // complicated, see spec.
#define CACHERR_EI 0x01000000 // complicated, see spec.
#define CACHERR_SIDX_MASK 0x003FFFF8 // secondary cache index
#define CACHERR_PIDX_MASK 0x00000007 // primary cache index
#define CACHERR_PIDX_SHIFT 12 // bits 2..0 are paddr14..12
/*
/*
* R4000 family supports hardware watchpoints:
* C0_WATCHLO:
* bits 31..3 are bits 31..3 of physaddr to watch
@ -305,63 +305,63 @@
* bits 31..4 are reserved and must be written as zeros.
* bits 3..0 are bits 35..32 of the physaddr to watch
*/
#define WATCHLO_WTRAP 0x00000001
#define WATCHLO_RTRAP 0x00000002
#define WATCHLO_ADDRMASK 0xFFFFFFF8
#define WATCHLO_VALIDMASK 0xFFFFFFFB
#define WATCHHI_VALIDMASK 0x0000000F
#define WATCHLO_WTRAP 0x00000001
#define WATCHLO_RTRAP 0x00000002
#define WATCHLO_ADDRMASK 0xFFFFFFF8
#define WATCHLO_VALIDMASK 0xFFFFFFFB
#define WATCHHI_VALIDMASK 0x0000000F
// Coprocessor 0 registers
#define C0_INX C_REG(0)
#define C0_RAND C_REG(1)
#define C0_ENTRYLO0 C_REG(2)
#define C0_ENTRYLO1 C_REG(3)
#define C0_CONTEXT C_REG(4)
#define C0_PAGEMASK C_REG(5) // page mask
#define C0_WIRED C_REG(6) // # wired entries in tlb
#define C0_BADVADDR C_REG(8)
#define C0_COUNT C_REG(9) // free-running counter
#define C0_ENTRYHI C_REG(10)
#define C0_COMPARE C_REG(11) // counter comparison reg.
#define C0_SR C_REG(12)
#define C0_CAUSE C_REG(13)
#define C0_EPC C_REG(14)
#define C0_PRID C_REG(15) // revision identifier
#define C0_CONFIG C_REG(16) // hardware configuration
#define C0_LLADDR C_REG(17) // load linked address
#define C0_WATCHLO C_REG(18) // watchpoint
#define C0_WATCHHI C_REG(19) // watchpoint
#define C0_ECC C_REG(26) // S-cache ECC and primary parity
#define C0_CACHE_ERR C_REG(27) // cache error status
#define C0_TAGLO C_REG(28) // cache operations
#define C0_TAGHI C_REG(29) // cache operations
#define C0_ERROR_EPC C_REG(30) // ECC error prg. counter
#define C0_INX C_REG(0)
#define C0_RAND C_REG(1)
#define C0_ENTRYLO0 C_REG(2)
#define C0_ENTRYLO1 C_REG(3)
#define C0_CONTEXT C_REG(4)
#define C0_PAGEMASK C_REG(5) // page mask
#define C0_WIRED C_REG(6) // # wired entries in tlb
#define C0_BADVADDR C_REG(8)
#define C0_COUNT C_REG(9) // free-running counter
#define C0_ENTRYHI C_REG(10)
#define C0_COMPARE C_REG(11) // counter comparison reg.
#define C0_SR C_REG(12)
#define C0_CAUSE C_REG(13)
#define C0_EPC C_REG(14)
#define C0_PRID C_REG(15) // revision identifier
#define C0_CONFIG C_REG(16) // hardware configuration
#define C0_LLADDR C_REG(17) // load linked address
#define C0_WATCHLO C_REG(18) // watchpoint
#define C0_WATCHHI C_REG(19) // watchpoint
#define C0_ECC C_REG(26) // S-cache ECC and primary parity
#define C0_CACHE_ERR C_REG(27) // cache error status
#define C0_TAGLO C_REG(28) // cache operations
#define C0_TAGHI C_REG(29) // cache operations
#define C0_ERROR_EPC C_REG(30) // ECC error prg. counter
// floating-point status register
#define C1_FPCSR C_REG(31)
// floating-point status register
#define C1_FPCSR C_REG(31)
#define FPCSR_FS 0x01000000 // flush denorm to zero
#define FPCSR_C 0x00800000 // condition bit
#define FPCSR_CE 0x00020000 // cause: unimplemented operation
#define FPCSR_CV 0x00010000 // cause: invalid operation
#define FPCSR_CZ 0x00008000 // cause: division by zero
#define FPCSR_CO 0x00004000 // cause: overflow
#define FPCSR_CU 0x00002000 // cause: underflow
#define FPCSR_CI 0x00001000 // cause: inexact operation
#define FPCSR_EV 0x00000800 // enable: invalid operation
#define FPCSR_EZ 0x00000400 // enable: division by zero
#define FPCSR_EO 0x00000200 // enable: overflow
#define FPCSR_EU 0x00000100 // enable: underflow
#define FPCSR_EI 0x00000080 // enable: inexact operation
#define FPCSR_FV 0x00000040 // flag: invalid operation
#define FPCSR_FZ 0x00000020 // flag: division by zero
#define FPCSR_FO 0x00000010 // flag: overflow
#define FPCSR_FU 0x00000008 // flag: underflow
#define FPCSR_FI 0x00000004 // flag: inexact operation
#define FPCSR_RM_MASK 0x00000003 // rounding mode mask
#define FPCSR_RM_RN 0x00000000 // round to nearest
#define FPCSR_RM_RZ 0x00000001 // round to zero
#define FPCSR_RM_RP 0x00000002 // round to positive infinity
#define FPCSR_RM_RM 0x00000003 // round to negative infinity
#define FPCSR_FS 0x01000000 // flush denorm to zero
#define FPCSR_C 0x00800000 // condition bit
#define FPCSR_CE 0x00020000 // cause: unimplemented operation
#define FPCSR_CV 0x00010000 // cause: invalid operation
#define FPCSR_CZ 0x00008000 // cause: division by zero
#define FPCSR_CO 0x00004000 // cause: overflow
#define FPCSR_CU 0x00002000 // cause: underflow
#define FPCSR_CI 0x00001000 // cause: inexact operation
#define FPCSR_EV 0x00000800 // enable: invalid operation
#define FPCSR_EZ 0x00000400 // enable: division by zero
#define FPCSR_EO 0x00000200 // enable: overflow
#define FPCSR_EU 0x00000100 // enable: underflow
#define FPCSR_EI 0x00000080 // enable: inexact operation
#define FPCSR_FV 0x00000040 // flag: invalid operation
#define FPCSR_FZ 0x00000020 // flag: division by zero
#define FPCSR_FO 0x00000010 // flag: overflow
#define FPCSR_FU 0x00000008 // flag: underflow
#define FPCSR_FI 0x00000004 // flag: inexact operation
#define FPCSR_RM_MASK 0x00000003 // rounding mode mask
#define FPCSR_RM_RN 0x00000000 // round to nearest
#define FPCSR_RM_RZ 0x00000001 // round to zero
#define FPCSR_RM_RP 0x00000002 // round to positive infinity
#define FPCSR_RM_RM 0x00000003 // round to negative infinity
#endif

70
include/ultra64/rcp.h
View File

@ -3,28 +3,28 @@
struct HardwareRegisters
{
uintptr_t SP_MEM_ADDR_REG = 0; // = 0x04040000;
uintptr_t SP_MEM_ADDR_REG = 0; // = 0x04040000;
uintptr_t SP_DRAM_ADDR_REG = 0; // = 0x04040004;
uintptr_t SP_RD_LEN_REG = 0; // = 0x04040008;
uintptr_t SP_WR_LEN_REG = 0; // = 0x0404000C;
uintptr_t SP_STATUS_REG = 0; // = 0x04040010;
uintptr_t SP_PC_REG = 0; // = 0x04080000;
uintptr_t SP_RD_LEN_REG = 0; // = 0x04040008;
uintptr_t SP_WR_LEN_REG = 0; // = 0x0404000C;
uintptr_t SP_STATUS_REG = 0; // = 0x04040010;
uintptr_t SP_PC_REG = 0; // = 0x04080000;
uintptr_t MI_INIT_MODE_REG = 0; // = 0x04300000;
uintptr_t MI_VERSION_REG = 0; // = 0x04300004;
uintptr_t MI_INTR_REG = 0; // = 0x04300008;
uintptr_t MI_INTR_MASK_REG = 0; // = 0x0430000C;
uintptr_t MI_VERSION_REG = 0; // = 0x04300004;
uintptr_t MI_INTR_REG = 0; // = 0x04300008;
uintptr_t MI_INTR_MASK_REG = 0; // = 0x0430000C;
uintptr_t VI_STATUS_REG = 0; // = 0x04400000;
uintptr_t VI_ORIGIN_REG = 0; // = 0x04400004;
uintptr_t VI_WIDTH_REG = 0; // = 0x04400008;
uintptr_t VI_INTR_REG = 0; // = 0x0440000C;
uintptr_t VI_STATUS_REG = 0; // = 0x04400000;
uintptr_t VI_ORIGIN_REG = 0; // = 0x04400004;
uintptr_t VI_WIDTH_REG = 0; // = 0x04400008;
uintptr_t VI_INTR_REG = 0; // = 0x0440000C;
uintptr_t VI_CURRENT_REG = 0; // = 0x04400010;
uintptr_t VI_BURST_REG = 0; // = 0x04400014;
uintptr_t VI_V_SYNC_REG = 0; // = 0x04400018; // VI vertical sync
uintptr_t VI_BURST_REG = 0; // = 0x04400014;
uintptr_t VI_V_SYNC_REG = 0; // = 0x04400018; // VI vertical sync
uintptr_t VI_H_SYNC_REG = 0; // = 0x0440001C; // VI horizontal sync
uintptr_t VI_LEAP_REG = 0; // = 0x04400020; // VI horizontal sync leap
uintptr_t VI_H_SYNC_REG = 0; // = 0x0440001C; // VI horizontal sync
uintptr_t VI_LEAP_REG = 0; // = 0x04400020; // VI horizontal sync leap
uintptr_t VI_H_START_REG = 0; // = 0x04400024; // VI horizontal video
uintptr_t VI_V_START_REG = 0; // = 0x04400028; // VI vertical video
uintptr_t VI_V_BURST_REG = 0; // = 0x0440002C; // VI vertical burst
@ -32,11 +32,11 @@ struct HardwareRegisters
uintptr_t VI_Y_SCALE_REG = 0; // = 0x04400034; // VI y-scale
uintptr_t AI_DRAM_ADDR_REG = 0; // = 0x04500000;
uintptr_t AI_LEN_REG = 0; // = 0x04500004;
uintptr_t AI_CONTROL_REG = 0; // = 0x04500008;
intptr_t AI_STATUS_REG = 0; // = 0x0450000C;
uintptr_t AI_DACRATE_REG = 0; // = 0x04500010;
uintptr_t AI_BITRATE_REG = 0; // = 0x04500014;
uintptr_t AI_LEN_REG = 0; // = 0x04500004;
uintptr_t AI_CONTROL_REG = 0; // = 0x04500008;
intptr_t AI_STATUS_REG = 0; // = 0x0450000C;
uintptr_t AI_DACRATE_REG = 0; // = 0x04500010;
uintptr_t AI_BITRATE_REG = 0; // = 0x04500014;
};
extern HardwareRegisters hw_regs;
@ -44,24 +44,22 @@ extern HardwareRegisters hw_regs;
#define AI_STATUS_AI_FULL (1 << 31)
#define AI_STATUS_AI_BUSY (1 << 30)
#define PI_STATUS_BUSY 0x1
#define PI_STATUS_IOBUSY 0x2
#define PI_STATUS_ERROR 0x4
#define PI_STATUS_BUSY 0x1
#define PI_STATUS_IOBUSY 0x2
#define PI_STATUS_ERROR 0x4
#define PI_STATUS_RESET_CONTROLLER 0x1
#define PI_STATUS_CLEAR_INTR 0x2
#define PI_STATUS_RESET_CONTROLLER 0x1
#define PI_STATUS_CLEAR_INTR 0x2
#define SI_STATUS_DMA_BUSY 0x1
#define SI_STATUS_IO_READ_BUSY 0x2
#define SI_STATUS_DMA_ERROR 0x8
#define SI_STATUS_INTERRUPT (1 << 12)
#define PIF_RAM_START 0x1FC007C0
#define SI_STATUS_DMA_BUSY 0x1
#define SI_STATUS_IO_READ_BUSY 0x2
#define SI_STATUS_DMA_ERROR 0x8
#define SI_STATUS_INTERRUPT (1 << 12)
#define PIF_RAM_START 0x1FC007C0
#define VI_NTSC_CLOCK 48681812 /* Hz = 48.681812 MHz */
#define VI_PAL_CLOCK 49656530 /* Hz = 49.656530 MHz */
#define VI_MPAL_CLOCK 48628316 /* Hz = 48.628316 MHz */
#define VI_NTSC_CLOCK 48681812 /* Hz = 48.681812 MHz */
#define VI_PAL_CLOCK 49656530 /* Hz = 49.656530 MHz */
#define VI_MPAL_CLOCK 48628316 /* Hz = 48.628316 MHz */
#endif

64
include/ultra64/rdp.h
View File

@ -5,47 +5,47 @@
#define DPC_REG_BASE 0xA4100000
#define DPC_START_REG (*(vu32*)(DPC_REG_BASE + 0x00))
#define DPC_END_REG (*(vu32*)(DPC_REG_BASE + 0x04))
#define DPC_CURRENT_REG (*(vu32*)(DPC_REG_BASE + 0x08))
#define DPC_STATUS_REG (*(vu32*)(DPC_REG_BASE + 0x0C))
#define DPC_CLOCK_REG (*(vu32*)(DPC_REG_BASE + 0x10))
#define DPC_BUFBUSY_REG (*(vu32*)(DPC_REG_BASE + 0x14))
#define DPC_PIPEBUSY_REG (*(vu32*)(DPC_REG_BASE + 0x18))
#define DPC_TMEM_REG (*(vu32*)(DPC_REG_BASE + 0x1C))
#define DPC_START_REG (*(vu32*)(DPC_REG_BASE + 0x00))
#define DPC_END_REG (*(vu32*)(DPC_REG_BASE + 0x04))
#define DPC_CURRENT_REG (*(vu32*)(DPC_REG_BASE + 0x08))
#define DPC_STATUS_REG (*(vu32*)(DPC_REG_BASE + 0x0C))
#define DPC_CLOCK_REG (*(vu32*)(DPC_REG_BASE + 0x10))
#define DPC_BUFBUSY_REG (*(vu32*)(DPC_REG_BASE + 0x14))
#define DPC_PIPEBUSY_REG (*(vu32*)(DPC_REG_BASE + 0x18))
#define DPC_TMEM_REG (*(vu32*)(DPC_REG_BASE + 0x1C))
/* DP Span Registers */
#define DPS_REG_BASE 0xA4200000
#define DPS_REG_BASE 0xA4200000
#define DPS_TBIST_REG (*(vu32*)(DPS_REG_BASE + 0x00))
#define DPS_TEST_MODE_REG (*(vu32*)(DPS_REG_BASE + 0x04))
#define DPS_TBIST_REG (*(vu32*)(DPS_REG_BASE + 0x00))
#define DPS_TEST_MODE_REG (*(vu32*)(DPS_REG_BASE + 0x04))
#define DPS_BUFTEST_ADDR_REG (*(vu32*)(DPS_REG_BASE + 0x08))
#define DPS_BUFTEST_DATA_REG (*(vu32*)(DPS_REG_BASE + 0x0C))
/* DP Status Read Flags */
#define DPC_STATUS_XBUS_DMEM_DMA 0x001
#define DPC_STATUS_FREEZE 0x002
#define DPC_STATUS_FLUSH 0x004
#define DPC_STATUS_START_GCLK 0x008
#define DPC_STATUS_TMEM_BUSY 0x010
#define DPC_STATUS_PIPE_BUSY 0x020
#define DPC_STATUS_CMD_BUSY 0x040
#define DPC_STATUS_CBUF_READY 0x080
#define DPC_STATUS_DMA_BUSY 0x100
#define DPC_STATUS_END_VALID 0x200
#define DPC_STATUS_START_VALID 0x400
#define DPC_STATUS_XBUS_DMEM_DMA 0x001
#define DPC_STATUS_FREEZE 0x002
#define DPC_STATUS_FLUSH 0x004
#define DPC_STATUS_START_GCLK 0x008
#define DPC_STATUS_TMEM_BUSY 0x010
#define DPC_STATUS_PIPE_BUSY 0x020
#define DPC_STATUS_CMD_BUSY 0x040
#define DPC_STATUS_CBUF_READY 0x080
#define DPC_STATUS_DMA_BUSY 0x100
#define DPC_STATUS_END_VALID 0x200
#define DPC_STATUS_START_VALID 0x400
/* DP Status Write Flags */
#define DPC_CLR_XBUS_DMEM_DMA 0x0001
#define DPC_SET_XBUS_DMEM_DMA 0x0002
#define DPC_CLR_FREEZE 0x0004
#define DPC_SET_FREEZE 0x0008
#define DPC_CLR_FLUSH 0x0010
#define DPC_SET_FLUSH 0x0020
#define DPC_CLR_TMEM_CTR 0x0040
#define DPC_CLR_PIPE_CTR 0x0080
#define DPC_CLR_CMD_CTR 0x0100
#define DPC_CLR_CLOCK_CTR 0x0200
#define DPC_CLR_XBUS_DMEM_DMA 0x0001
#define DPC_SET_XBUS_DMEM_DMA 0x0002
#define DPC_CLR_FREEZE 0x0004
#define DPC_SET_FREEZE 0x0008
#define DPC_CLR_FLUSH 0x0010
#define DPC_SET_FLUSH 0x0020
#define DPC_CLR_TMEM_CTR 0x0040
#define DPC_CLR_PIPE_CTR 0x0080
#define DPC_CLR_CMD_CTR 0x0100
#define DPC_CLR_CLOCK_CTR 0x0200
#endif

80
include/ultra64/rsp.h
View File

@ -2,49 +2,49 @@
#define ULTRA64_RSP_H
/* SP Status Flags */
#define SP_STATUS_HALT 0x001
#define SP_STATUS_BROKE 0x002
#define SP_STATUS_DMA_BUSY 0x004
#define SP_STATUS_DMA_FULL 0x008
#define SP_STATUS_IO_FULL 0x010
#define SP_STATUS_SSTEP 0x020
#define SP_STATUS_INTR_BREAK 0x040
#define SP_STATUS_YIELD 0x080
#define SP_STATUS_YIELDED 0x100
#define SP_STATUS_TASKDONE 0x200
#define SP_STATUS_HALT 0x001
#define SP_STATUS_BROKE 0x002
#define SP_STATUS_DMA_BUSY 0x004
#define SP_STATUS_DMA_FULL 0x008
#define SP_STATUS_IO_FULL 0x010
#define SP_STATUS_SSTEP 0x020
#define SP_STATUS_INTR_BREAK 0x040
#define SP_STATUS_YIELD 0x080
#define SP_STATUS_YIELDED 0x100
#define SP_STATUS_TASKDONE 0x200
//#define SP_STATUS_SIG0 0x080
//#define SP_STATUS_SIG1 0x100
//#define SP_STATUS_SIG2 0x200
#define SP_STATUS_SIG3 0x400
#define SP_STATUS_SIG4 0x800
#define SP_STATUS_SIG5 0x1000
#define SP_STATUS_SIG6 0x2000
#define SP_STATUS_SIG7 0x4000
#define SP_STATUS_SIG3 0x400
#define SP_STATUS_SIG4 0x800
#define SP_STATUS_SIG5 0x1000
#define SP_STATUS_SIG6 0x2000
#define SP_STATUS_SIG7 0x4000
#define SP_CLR_HALT 0x00001
#define SP_SET_HALT 0x00002
#define SP_CLR_BROKE 0x00004
#define SP_CLR_INTR 0x00008
#define SP_SET_INTR 0x00010
#define SP_CLR_SSTEP 0x00020
#define SP_SET_SSTEP 0x00040
#define SP_CLR_INTR_BREAK 0x00080
#define SP_SET_INTR_BREAK 0x00100
#define SP_CLR_SIG0 0x00200
#define SP_SET_SIG0 0x00400
#define SP_CLR_SIG1 0x00800
#define SP_SET_SIG1 0x01000
#define SP_CLR_SIG2 0x02000
#define SP_SET_SIG2 0x04000
#define SP_CLR_SIG3 0x08000
#define SP_SET_SIG3 0x10000
#define SP_CLR_SIG4 0x20000
#define SP_SET_SIG4 0x40000
#define SP_CLR_SIG5 0x80000
#define SP_SET_SIG5 0x100000
#define SP_CLR_SIG6 0x200000
#define SP_SET_SIG6 0x400000
#define SP_CLR_SIG7 0x800000
#define SP_SET_SIG7 0x1000000
#define SP_CLR_HALT 0x00001
#define SP_SET_HALT 0x00002
#define SP_CLR_BROKE 0x00004
#define SP_CLR_INTR 0x00008
#define SP_SET_INTR 0x00010
#define SP_CLR_SSTEP 0x00020
#define SP_SET_SSTEP 0x00040
#define SP_CLR_INTR_BREAK 0x00080
#define SP_SET_INTR_BREAK 0x00100
#define SP_CLR_SIG0 0x00200
#define SP_SET_SIG0 0x00400
#define SP_CLR_SIG1 0x00800
#define SP_SET_SIG1 0x01000
#define SP_CLR_SIG2 0x02000
#define SP_SET_SIG2 0x04000
#define SP_CLR_SIG3 0x08000
#define SP_SET_SIG3 0x10000
#define SP_CLR_SIG4 0x20000
#define SP_SET_SIG4 0x40000
#define SP_CLR_SIG5 0x80000
#define SP_SET_SIG5 0x100000
#define SP_CLR_SIG6 0x200000
#define SP_SET_SIG6 0x400000
#define SP_CLR_SIG7 0x800000
#define SP_SET_SIG7 0x1000000
#endif

123
include/ultra64/sched.h
View File

@ -1,8 +1,8 @@
#pragma once
#include "ultra64/types.h"
#include "ultra64/sptask.h"
#include "ultra64/message.h"
#include "ultra64/sptask.h"
#include "ultra64/time.h"
#include "ultra64/types.h"
#include "unk.h"
#define OS_SC_RETRACE_MSG 1
@ -25,73 +25,78 @@
#define OS_SC_RCP_MASK 0x0003
#define OS_SC_TYPE_MASK 0x0007
struct OSScMsg {
/* 0x00 */ s16 type;
/* 0x02 */ char misc[0x1E];
struct OSScMsg
{
/* 0x00 */ s16 type;
/* 0x02 */ char misc[0x1E];
}; // size = 0x20
struct IrqMgrClient {
/* 0x00 */ struct IrqMgrClient* prev;
/* 0x04 */ OSMesgQueue* queue;
struct IrqMgrClient
{
/* 0x00 */ struct IrqMgrClient* prev;
/* 0x04 */ OSMesgQueue* queue;
};
struct IrqMgr {
/* 0x000 */ OSScMsg retraceMsg; // this apparently got moved from OSSched
/* 0x020 */ OSScMsg prenmiMsg; // this apparently got moved from OSSched
/* 0x040 */ OSScMsg nmiMsg;
/* 0x060 */ OSMesgQueue queue;
/* 0x078 */ OSMesg msgBuf[8];
/* 0x098 */ OSThread thread;
/* 0x248 */ IrqMgrClient* clients;
/* 0x24C */ u8 resetStatus;
/* 0x250 */ OSTime resetTime;
/* 0x258 */ OSTimer timer;
/* 0x278 */ OSTime retraceTime;
struct IrqMgr
{
/* 0x000 */ OSScMsg retraceMsg; // this apparently got moved from OSSched
/* 0x020 */ OSScMsg prenmiMsg; // this apparently got moved from OSSched
/* 0x040 */ OSScMsg nmiMsg;
/* 0x060 */ OSMesgQueue queue;
/* 0x078 */ OSMesg msgBuf[8];
/* 0x098 */ OSThread thread;
/* 0x248 */ IrqMgrClient* clients;
/* 0x24C */ u8 resetStatus;
/* 0x250 */ OSTime resetTime;
/* 0x258 */ OSTimer timer;
/* 0x278 */ OSTime retraceTime;
}; // size = 0x280
struct CfbInfo {
/* 0x00 */ u16* fb1;
/* 0x04 */ u16* swapBuffer;
/* 0x08 */ struct OSViMode* viMode;
/* 0x0C */ u32 features;
/* 0x10 */ u8 unk_10;
/* 0x11 */ s8 updateRate;
/* 0x12 */ s8 updateRate2;
/* 0x13 */ u8 unk_13;
/* 0x14 */ f32 xScale;
/* 0x18 */ f32 yScale;
struct CfbInfo
{
/* 0x00 */ u16* fb1;
/* 0x04 */ u16* swapBuffer;
/* 0x08 */ struct OSViMode* viMode;
/* 0x0C */ u32 features;
/* 0x10 */ u8 unk_10;
/* 0x11 */ s8 updateRate;
/* 0x12 */ s8 updateRate2;
/* 0x13 */ u8 unk_13;
/* 0x14 */ f32 xScale;
/* 0x18 */ f32 yScale;
}; // size = 0x1C
struct OSScTask {
/* 0x00 */ struct OSScTask* next;
/* 0x04 */ u32 state;
/* 0x08 */ u32 flags;
/* 0x0C */ CfbInfo* framebuffer;
/* 0x10 */ OSTask list;
/* 0x50 */ OSMesgQueue* msgQ;
/* 0x54 */ OSMesg msg;
struct OSScTask
{
/* 0x00 */ struct OSScTask* next;
/* 0x04 */ u32 state;
/* 0x08 */ u32 flags;
/* 0x0C */ CfbInfo* framebuffer;
/* 0x10 */ OSTask list;
/* 0x50 */ OSMesgQueue* msgQ;
/* 0x54 */ OSMesg msg;
};
struct SchedContext {
/* 0x0000 */ OSMesgQueue interruptQ;
/* 0x0018 */ OSMesg intBuf[8];
/* 0x0038 */ OSMesgQueue cmdQ;
/* 0x0050 */ OSMesg cmdMsgBuf[8];
/* 0x0070 */ OSThread thread;
/* 0x0220 */ OSScTask* audioListHead;
/* 0x0224 */ OSScTask* gfxListHead;
/* 0x0228 */ OSScTask* audioListTail;
/* 0x022C */ OSScTask* gfxListTail;
/* 0x0230 */ OSScTask* curRSPTask;
/* 0x0234 */ OSScTask* curRDPTask;
/* 0x0238 */ s32 retraceCnt;
/* 0x023C */ s32 doAudio;
/* 0x0240 */ CfbInfo* curBuf;
/* 0x0244 */ CfbInfo* pendingSwapBuf1;
/* 0x0220 */ CfbInfo* pendingSwapBuf2;
/* 0x0220 */ UNK_TYPE4 unk_24C;
/* 0x0250 */ IrqMgrClient irqClient;
struct SchedContext
{
/* 0x0000 */ OSMesgQueue interruptQ;
/* 0x0018 */ OSMesg intBuf[8];
/* 0x0038 */ OSMesgQueue cmdQ;
/* 0x0050 */ OSMesg cmdMsgBuf[8];
/* 0x0070 */ OSThread thread;
/* 0x0220 */ OSScTask* audioListHead;
/* 0x0224 */ OSScTask* gfxListHead;
/* 0x0228 */ OSScTask* audioListTail;
/* 0x022C */ OSScTask* gfxListTail;
/* 0x0230 */ OSScTask* curRSPTask;
/* 0x0234 */ OSScTask* curRDPTask;
/* 0x0238 */ s32 retraceCnt;
/* 0x023C */ s32 doAudio;
/* 0x0240 */ CfbInfo* curBuf;
/* 0x0244 */ CfbInfo* pendingSwapBuf1;
/* 0x0220 */ CfbInfo* pendingSwapBuf2;
/* 0x0220 */ UNK_TYPE4 unk_24C;
/* 0x0250 */ IrqMgrClient irqClient;
}; // size = 0x258
extern SchedContext gSchedContext;

76
include/ultra64/sptask.h
View File

@ -4,65 +4,67 @@
#include "types.h"
/* Task Types */
#define M_NULTASK 0
#define M_GFXTASK 1
#define M_AUDTASK 2
#define M_VIDTASK 3
#define M_NULTASK 0
#define M_GFXTASK 1
#define M_AUDTASK 2
#define M_VIDTASK 3
#define M_NJPEGTASK 4
#define M_HVQTASK 6
#define M_HVQMTASK 7
#define M_HVQTASK 6
#define M_HVQMTASK 7
/* Task Flags */
#define M_TASK_FLAG0 1
#define M_TASK_FLAG1 2
/* Task Flag Fields */
#define OS_TASK_YIELDED 0x0001
#define OS_TASK_DP_WAIT 0x0002
#define OS_TASK_LOADABLE 0x0004
#define OS_TASK_SP_ONLY 0x0008
#define OS_TASK_USR0 0x0010
#define OS_TASK_USR1 0x0020
#define OS_TASK_USR2 0x0040
#define OS_TASK_USR3 0x0080
#define OS_TASK_YIELDED 0x0001
#define OS_TASK_DP_WAIT 0x0002
#define OS_TASK_LOADABLE 0x0004
#define OS_TASK_SP_ONLY 0x0008
#define OS_TASK_USR0 0x0010
#define OS_TASK_USR1 0x0020
#define OS_TASK_USR2 0x0040
#define OS_TASK_USR3 0x0080
#define OS_YIELD_DATA_SIZE 0xC00
struct OSTask_t {
/* 0x00 */ u32 type;
/* 0x04 */ u32 flags;
struct OSTask_t
{
/* 0x00 */ u32 type;
/* 0x04 */ u32 flags;
/* 0x08 */ u64* ucode_boot;
/* 0x0C */ u32 ucode_boot_size;
/* 0x08 */ u64* ucode_boot;
/* 0x0C */ u32 ucode_boot_size;
/* 0x10 */ u64* ucode;
/* 0x14 */ u32 ucode_size;
/* 0x10 */ u64* ucode;
/* 0x14 */ u32 ucode_size;
/* 0x18 */ u64* ucode_data;
/* 0x1C */ u32 ucode_data_size;
/* 0x18 */ u64* ucode_data;
/* 0x1C */ u32 ucode_data_size;
/* 0x20 */ u64* dram_stack;
/* 0x24 */ u32 dram_stack_size;
/* 0x20 */ u64* dram_stack;
/* 0x24 */ u32 dram_stack_size;
/* 0x28 */ u64* output_buff;
/* 0x2C */ u64* output_buff_size;
/* 0x28 */ u64* output_buff;
/* 0x2C */ u64* output_buff_size;
/* 0x30 */ u64* data_ptr;
/* 0x34 */ u32 data_size;
/* 0x30 */ u64* data_ptr;
/* 0x34 */ u32 data_size;
/* 0x38 */ u64* yield_data_ptr;
/* 0x3C */ u32 yield_data_size;
/* 0x38 */ u64* yield_data_ptr;
/* 0x3C */ u32 yield_data_size;
}; // size = 0x40
union OSTask {
OSTask_t t;
long long int force_structure_alignment;
union OSTask
{
OSTask_t t;
long long int force_structure_alignment;
};
typedef u32 OSYieldResult;
#define osSpTaskStart(p) \
osSpTaskLoad(p); \
osSpTaskStartGo(p);
#define osSpTaskStart(p) \
osSpTaskLoad(p); \
osSpTaskStartGo(p);
#endif

91
include/ultra64/thread.h
View File

@ -3,62 +3,67 @@
#include "types.h"
#define OS_PRIORITY_MAX 255
#define OS_PRIORITY_VIMGR 254
#define OS_PRIORITY_RMON 250
#define OS_PRIORITY_MAX 255
#define OS_PRIORITY_VIMGR 254
#define OS_PRIORITY_RMON 250
#define OS_PRIORITY_RMONSPIN 200
#define OS_PRIORITY_PIMGR 150
#define OS_PRIORITY_SIMGR 140
#define OS_PRIORITY_APPMAX 127
#define OS_PRIORITY_IDLE 0
#define OS_PRIORITY_PIMGR 150
#define OS_PRIORITY_SIMGR 140
#define OS_PRIORITY_APPMAX 127
#define OS_PRIORITY_IDLE 0
#define OS_STATE_STOPPED 1
#define OS_STATE_RUNNABLE 2
#define OS_STATE_RUNNING 4
#define OS_STATE_WAITING 8
#define OS_STATE_STOPPED 1
#define OS_STATE_RUNNABLE 2
#define OS_STATE_RUNNING 4
#define OS_STATE_WAITING 8
#define OS_FLAG_CPU_BREAK 1
#define OS_FLAG_FAULT 2
#define OS_FLAG_CPU_BREAK 1
#define OS_FLAG_FAULT 2
typedef s32 OSPri;
typedef s32 OSId;
typedef union {
struct {
/* 0x00 */ f32 f_odd;
/* 0x04 */ f32 f_even;
} f;
typedef union
{
struct
{
/* 0x00 */ f32 f_odd;
/* 0x04 */ f32 f_even;
} f;
} __OSfp; // size = 0x08
struct __OSThreadContext {
/* 0x000 */ u64 at, v0, v1, a0, a1, a2, a3;
/* 0x038 */ u64 t0, t1, t2, t3, t4, t5, t6, t7;
/* 0x078 */ u64 s0, s1, s2, s3, s4, s5, s6, s7;
/* 0x0B8 */ u64 t8, t9, gp, sp, s8, ra;
/* 0x0E8 */ u64 lo, hi;
/* 0x0F8 */ u32 sr, pc, cause, badvaddr, rcp;
/* 0x10C */ u32 fpcsr;
/* 0x110 */ __OSfp fp0, fp2, fp4, fp6, fp8, fp10, fp12, fp14;
/* 0x150 */ __OSfp fp16, fp18, fp20, fp22, fp24, fp26, fp28, fp30;
struct __OSThreadContext
{
/* 0x000 */ u64 at, v0, v1, a0, a1, a2, a3;
/* 0x038 */ u64 t0, t1, t2, t3, t4, t5, t6, t7;
/* 0x078 */ u64 s0, s1, s2, s3, s4, s5, s6, s7;
/* 0x0B8 */ u64 t8, t9, gp, sp, s8, ra;
/* 0x0E8 */ u64 lo, hi;
/* 0x0F8 */ u32 sr, pc, cause, badvaddr, rcp;
/* 0x10C */ u32 fpcsr;
/* 0x110 */ __OSfp fp0, fp2, fp4, fp6, fp8, fp10, fp12, fp14;
/* 0x150 */ __OSfp fp16, fp18, fp20, fp22, fp24, fp26, fp28, fp30;
}; // size = 0x190
struct __OSThreadprofile {
/* 0x00 */ u32 flag;
/* 0x04 */ u32 count;
/* 0x08 */ u64 time;
struct __OSThreadprofile
{
/* 0x00 */ u32 flag;
/* 0x04 */ u32 count;
/* 0x08 */ u64 time;
}; // size = 0x10
struct OSThread {
/* 0x00 */ struct OSThread* next;
/* 0x04 */ OSPri priority;
/* 0x08 */ struct OSThread** queue;
/* 0x0C */ struct OSThread* tlnext;
/* 0x10 */ u16 state;
/* 0x12 */ u16 flags;
/* 0x14 */ OSId id;
/* 0x18 */ s32 fp;
/* 0x1C */ __OSThreadprofile* thprof;
/* 0x20 */ __OSThreadContext context;
struct OSThread
{
/* 0x00 */ struct OSThread* next;
/* 0x04 */ OSPri priority;
/* 0x08 */ struct OSThread** queue;
/* 0x0C */ struct OSThread* tlnext;
/* 0x10 */ u16 state;
/* 0x12 */ u16 flags;
/* 0x14 */ OSId id;
/* 0x18 */ s32 fp;
/* 0x1C */ __OSThreadprofile* thprof;
/* 0x20 */ __OSThreadContext context;
}; // size = 0x1B0
#endif

15
include/ultra64/time.h
View File

@ -5,13 +5,14 @@
typedef u64 OSTime;
struct OSTimer {
/* 0x00 */ struct OSTimer* next;
/* 0x04 */ struct OSTimer* prev;
/* 0x08 */ OSTime interval;
/* 0x10 */ OSTime value;
/* 0x18 */ OSMesgQueue* mq;
/* 0x1C */ OSMesg msg;
struct OSTimer
{
/* 0x00 */ struct OSTimer* next;
/* 0x04 */ struct OSTimer* prev;
/* 0x08 */ OSTime interval;
/* 0x10 */ OSTime value;
/* 0x18 */ OSMesgQueue* mq;
/* 0x1C */ OSMesg msg;
}; // size = 0x20
#endif

84
include/ultra64/types.h
View File

@ -1,60 +1,61 @@
#pragma once
#pragma warning (error: 4715)
#pragma warning (error: 4716)
#pragma warning (error: 4013)
#pragma warning(error : 4715)
#pragma warning(error : 4716)
#pragma warning(error : 4013)
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
typedef signed char s8;
typedef unsigned char u8;
typedef signed short int s16;
typedef unsigned short int u16;
typedef signed int s32;
typedef unsigned int u32;
typedef signed long long int s64;
typedef signed char s8;
typedef unsigned char u8;
typedef signed short int s16;
typedef unsigned short int u16;
typedef signed int s32;
typedef unsigned int u32;
typedef signed long long int s64;
typedef unsigned long long int u64;
typedef volatile u8 vu8;
typedef volatile u8 vu8;
typedef volatile u16 vu16;
typedef volatile u32 vu32;
typedef volatile u64 vu64;
typedef volatile s8 vs8;
typedef volatile s8 vs8;
typedef volatile s16 vs16;
typedef volatile s32 vs32;
typedef volatile s64 vs64;
typedef float f32;
typedef float f32;
typedef double f64;
#ifndef GBI_FLOATS
typedef s32 Mtx_t[4][4];
typedef union {
Mtx_t m;
struct {
u16 intPart[4][4];
u16 fracPart[4][4];
};
long long int forc_structure_alignment;
typedef union
{
Mtx_t m;
struct
{
u16 intPart[4][4];
u16 fracPart[4][4];
};
long long int forc_structure_alignment;
} Mtx;
#else
struct Mtx {
float m[4][4];
struct Mtx
{
float m[4][4];
};
#endif
typedef float MtxF_t[4][4];
typedef union {
MtxF_t mf;
struct {
float xx, yx, zx, wx,
xy, yy, zy, wy,
xz, yz, zz, wz,
xw, yw, zw, ww;
};
typedef union
{
MtxF_t mf;
struct
{
float xx, yx, zx, wx, xy, yy, zy, wy, xz, yz, zz, wz, xw, yw, zw, ww;
};
} MtxF;
class Pointer
@ -64,7 +65,7 @@ class Pointer
{
}
constexpr Pointer(uintptr_t address) : m_address(address)
constexpr Pointer(uintptr_t address) : m_address(address)
{
}
@ -80,7 +81,7 @@ class Pointer
{
}
constexpr Pointer(const s8* address) : m_address((uintptr_t)address)
constexpr Pointer(const s8* address) : m_address((uintptr_t)address)
{
}
@ -88,7 +89,7 @@ class Pointer
{
}
constexpr Pointer(const u8* address) : m_address((uintptr_t)address)
constexpr Pointer(const u8* address) : m_address((uintptr_t)address)
{
}
@ -104,7 +105,7 @@ class Pointer
{
}
constexpr Pointer(const u16* address) : m_address((uintptr_t)address)
constexpr Pointer(const u16* address) : m_address((uintptr_t)address)
{
}
@ -112,7 +113,7 @@ class Pointer
{
}
constexpr Pointer(const s32* address) : m_address((uintptr_t)address)
constexpr Pointer(const s32* address) : m_address((uintptr_t)address)
{
}
@ -120,7 +121,7 @@ class Pointer
{
}
constexpr Pointer(const u32* address) : m_address((uintptr_t)address)
constexpr Pointer(const u32* address) : m_address((uintptr_t)address)
{
}
@ -128,7 +129,7 @@ class Pointer
{
}
constexpr Pointer operator + (const Pointer& b) const
constexpr Pointer operator+(const Pointer& b) const
{
return Pointer(m_address + b.m_address);
}
@ -187,9 +188,9 @@ class Pointer
return m_address;
}
uintptr_t get()
uintptr_t get()
{
return m_address;
return m_address;
}
void* buffer()
@ -201,6 +202,7 @@ class Pointer
{
return (char*)m_address;
}
private:
uintptr_t m_address;
};

262
include/ultra64/vi.h
View File

@ -4,152 +4,158 @@
#include "message.h"
/* Special Features */
#define OS_VI_GAMMA_ON 0x0001
#define OS_VI_GAMMA_OFF 0x0002
#define OS_VI_GAMMA_DITHER_ON 0x0004
#define OS_VI_GAMMA_DITHER_OFF 0x0008
#define OS_VI_DIVOT_ON 0x0010
#define OS_VI_DIVOT_OFF 0x0020
#define OS_VI_DITHER_FILTER_ON 0x0040
#define OS_VI_GAMMA_ON 0x0001
#define OS_VI_GAMMA_OFF 0x0002
#define OS_VI_GAMMA_DITHER_ON 0x0004
#define OS_VI_GAMMA_DITHER_OFF 0x0008
#define OS_VI_DIVOT_ON 0x0010
#define OS_VI_DIVOT_OFF 0x0020
#define OS_VI_DITHER_FILTER_ON 0x0040
#define OS_VI_DITHER_FILTER_OFF 0x0080
#define OS_VI_GAMMA 0x08
#define OS_VI_GAMMA_DITHER 0x04
#define OS_VI_DIVOT 0x10
#define OS_VI_GAMMA 0x08
#define OS_VI_GAMMA_DITHER 0x04
#define OS_VI_DIVOT 0x10
#define OS_VI_DITHER_FILTER 0x10000
#define OS_VI_UNK1 0x1
#define OS_VI_UNK2 0x2
#define OS_VI_UNK40 0x40
#define OS_VI_UNK100 0x100
#define OS_VI_UNK200 0x200
#define OS_VI_UNK1000 0x1000
#define OS_VI_UNK2000 0x2000
#define OS_VI_UNK1 0x1
#define OS_VI_UNK2 0x2
#define OS_VI_UNK40 0x40
#define OS_VI_UNK100 0x100
#define OS_VI_UNK200 0x200
#define OS_VI_UNK1000 0x1000
#define OS_VI_UNK2000 0x2000
struct OSViCommonRegs {
/* 0x00 */ u32 ctrl;
/* 0x04 */ u32 width;
/* 0x08 */ u32 burst;
/* 0x0C */ u32 vSync;
/* 0x10 */ u32 hSync;
/* 0x14 */ u32 leap;
/* 0x18 */ u32 hStart;
/* 0x1C */ u32 xScale;
/* 0x20 */ u32 vCurrent;
struct OSViCommonRegs
{
/* 0x00 */ u32 ctrl;
/* 0x04 */ u32 width;
/* 0x08 */ u32 burst;
/* 0x0C */ u32 vSync;
/* 0x10 */ u32 hSync;
/* 0x14 */ u32 leap;
/* 0x18 */ u32 hStart;
/* 0x1C */ u32 xScale;
/* 0x20 */ u32 vCurrent;
}; // size = 0x20
struct OSViFieldRegs {
/* 0x00 */ u32 origin;
/* 0x04 */ u32 yScale;
/* 0x08 */ u32 vStart;
/* 0x0C */ u32 vBurst;
/* 0x10 */ u32 vIntr;
struct OSViFieldRegs
{
/* 0x00 */ u32 origin;
/* 0x04 */ u32 yScale;
/* 0x08 */ u32 vStart;
/* 0x0C */ u32 vBurst;
/* 0x10 */ u32 vIntr;
}; // size = 0x14
struct OSViMode {
/* 0x00 */ u8 type;
/* 0x04 */ OSViCommonRegs comRegs;
/* 0x24 */ OSViFieldRegs fldRegs[2];
struct OSViMode
{
/* 0x00 */ u8 type;
/* 0x04 */ OSViCommonRegs comRegs;
/* 0x24 */ OSViFieldRegs fldRegs[2];
}; // size = 0x4C
struct __OSViScale {
/* 0x0 */ f32 factor;
/* 0x4 */ u16 offset;
/* 0x8 */ u32 scale;
struct __OSViScale
{
/* 0x0 */ f32 factor;
/* 0x4 */ u16 offset;
/* 0x8 */ u32 scale;
}; // size = 0x0C
struct OSViContext {
/* 0x00 */ u16 state;
/* 0x02 */ u16 retraceCount;
/* 0x04 */ void* buffer;
/* 0x08 */ OSViMode* modep;
/* 0x0C */ u32 features;
/* 0x10 */ OSMesgQueue* mq;
/* 0x14 */ OSMesg* msg;
/* 0x18 */ __OSViScale x;
/* 0x24 */ __OSViScale y;
struct OSViContext
{
/* 0x00 */ u16 state;
/* 0x02 */ u16 retraceCount;
/* 0x04 */ void* buffer;
/* 0x08 */ OSViMode* modep;
/* 0x0C */ u32 features;
/* 0x10 */ OSMesgQueue* mq;
/* 0x14 */ OSMesg* msg;
/* 0x18 */ __OSViScale x;
/* 0x24 */ __OSViScale y;
}; // size = 0x30
#define OS_VI_NTSC_LPN1 0 /* NTSC */
#define OS_VI_NTSC_LPF1 1
#define OS_VI_NTSC_LAN1 2
#define OS_VI_NTSC_LAF1 3
#define OS_VI_NTSC_LPN2 4
#define OS_VI_NTSC_LPF2 5
#define OS_VI_NTSC_LAN2 6
#define OS_VI_NTSC_LAF2 7
#define OS_VI_NTSC_HPN1 8
#define OS_VI_NTSC_HPF1 9
#define OS_VI_NTSC_HAN1 10
#define OS_VI_NTSC_HAF1 11
#define OS_VI_NTSC_HPN2 12
#define OS_VI_NTSC_HPF2 13
#define OS_VI_NTSC_LPN1 0 /* NTSC */
#define OS_VI_NTSC_LPF1 1
#define OS_VI_NTSC_LAN1 2
#define OS_VI_NTSC_LAF1 3
#define OS_VI_NTSC_LPN2 4
#define OS_VI_NTSC_LPF2 5
#define OS_VI_NTSC_LAN2 6
#define OS_VI_NTSC_LAF2 7
#define OS_VI_NTSC_HPN1 8
#define OS_VI_NTSC_HPF1 9
#define OS_VI_NTSC_HAN1 10
#define OS_VI_NTSC_HAF1 11
#define OS_VI_NTSC_HPN2 12
#define OS_VI_NTSC_HPF2 13
#define OS_VI_PAL_LPN1 14 /* PAL */
#define OS_VI_PAL_LPF1 15
#define OS_VI_PAL_LAN1 16
#define OS_VI_PAL_LAF1 17
#define OS_VI_PAL_LPN2 18
#define OS_VI_PAL_LPF2 19
#define OS_VI_PAL_LAN2 20
#define OS_VI_PAL_LAF2 21
#define OS_VI_PAL_HPN1 22
#define OS_VI_PAL_HPF1 23
#define OS_VI_PAL_HAN1 24
#define OS_VI_PAL_HAF1 25
#define OS_VI_PAL_HPN2 26
#define OS_VI_PAL_HPF2 27
#define OS_VI_PAL_LPN1 14 /* PAL */
#define OS_VI_PAL_LPF1 15
#define OS_VI_PAL_LAN1 16
#define OS_VI_PAL_LAF1 17
#define OS_VI_PAL_LPN2 18
#define OS_VI_PAL_LPF2 19
#define OS_VI_PAL_LAN2 20
#define OS_VI_PAL_LAF2 21
#define OS_VI_PAL_HPN1 22
#define OS_VI_PAL_HPF1 23
#define OS_VI_PAL_HAN1 24
#define OS_VI_PAL_HAF1 25
#define OS_VI_PAL_HPN2 26
#define OS_VI_PAL_HPF2 27
#define OS_VI_MPAL_LPN1 28 /* MPAL - mainly Brazil */
#define OS_VI_MPAL_LPF1 29
#define OS_VI_MPAL_LAN1 30
#define OS_VI_MPAL_LAF1 31
#define OS_VI_MPAL_LPN2 32
#define OS_VI_MPAL_LPF2 33
#define OS_VI_MPAL_LAN2 34
#define OS_VI_MPAL_LAF2 35
#define OS_VI_MPAL_HPN1 36
#define OS_VI_MPAL_HPF1 37
#define OS_VI_MPAL_HAN1 38
#define OS_VI_MPAL_HAF1 39
#define OS_VI_MPAL_HPN2 40
#define OS_VI_MPAL_HPF2 41
#define OS_VI_MPAL_LPN1 28 /* MPAL - mainly Brazil */
#define OS_VI_MPAL_LPF1 29
#define OS_VI_MPAL_LAN1 30
#define OS_VI_MPAL_LAF1 31
#define OS_VI_MPAL_LPN2 32
#define OS_VI_MPAL_LPF2 33
#define OS_VI_MPAL_LAN2 34
#define OS_VI_MPAL_LAF2 35
#define OS_VI_MPAL_HPN1 36
#define OS_VI_MPAL_HPF1 37
#define OS_VI_MPAL_HAN1 38
#define OS_VI_MPAL_HAF1 39
#define OS_VI_MPAL_HPN2 40
#define OS_VI_MPAL_HPF2 41
#define OS_VI_FPAL_LPN1 42 /* FPAL - Full screen PAL */
#define OS_VI_FPAL_LPF1 43
#define OS_VI_FPAL_LAN1 44
#define OS_VI_FPAL_LAF1 45
#define OS_VI_FPAL_LPN2 46
#define OS_VI_FPAL_LPF2 47
#define OS_VI_FPAL_LAN2 48
#define OS_VI_FPAL_LAF2 49
#define OS_VI_FPAL_HPN1 50
#define OS_VI_FPAL_HPF1 51
#define OS_VI_FPAL_HAN1 52
#define OS_VI_FPAL_HAF1 53
#define OS_VI_FPAL_HPN2 54
#define OS_VI_FPAL_HPF2 55
#define OS_VI_FPAL_LPN1 42 /* FPAL - Full screen PAL */
#define OS_VI_FPAL_LPF1 43
#define OS_VI_FPAL_LAN1 44
#define OS_VI_FPAL_LAF1 45
#define OS_VI_FPAL_LPN2 46
#define OS_VI_FPAL_LPF2 47
#define OS_VI_FPAL_LAN2 48
#define OS_VI_FPAL_LAF2 49
#define OS_VI_FPAL_HPN1 50
#define OS_VI_FPAL_HPF1 51
#define OS_VI_FPAL_HAN1 52
#define OS_VI_FPAL_HAF1 53
#define OS_VI_FPAL_HPN2 54
#define OS_VI_FPAL_HPF2 55
#define OS_TV_PAL 0
#define OS_TV_NTSC 1
#define OS_TV_MPAL 2
#define OS_VI_UNK28 28
#define OS_TV_PAL 0
#define OS_TV_NTSC 1
#define OS_TV_MPAL 2
#define OS_VI_UNK28 28
typedef struct {
/* 0x0000 */ OSViMode customViMode;
/* 0x0050 */ s32 viHeight;
/* 0x0054 */ s32 viWidth;
/* 0x0058 */ s32 unk_58; // Right adjustment?
/* 0x005C */ s32 unk_5C; // Left adjustment?
/* 0x0060 */ s32 unk_60; // Bottom adjustment?
/* 0x0064 */ s32 unk_64; // Top adjustment?
/* 0x0068 */ s32 viModeBase; // enum: {0, 1, 2, 3}
/* 0x006C */ s32 viTvType;
/* 0x0070 */ u32 unk_70; // bool
/* 0x0074 */ u32 unk_74; // bool
/* 0x0078 */ u32 unk_78; // bool
/* 0x007C */ u32 unk_7C; // bool
/* 0x0080 */ u32 viFeatures;
/* 0x0084 */ u32 unk_84;
} ViMode;
struct ViMode
{
/* 0x0000 */ OSViMode customViMode;
/* 0x0050 */ s32 viHeight;
/* 0x0054 */ s32 viWidth;
/* 0x0058 */ s32 unk_58; // Right adjustment?
/* 0x005C */ s32 unk_5C; // Left adjustment?
/* 0x0060 */ s32 unk_60; // Bottom adjustment?
/* 0x0064 */ s32 unk_64; // Top adjustment?
/* 0x0068 */ s32 viModeBase; // enum: {0, 1, 2, 3}
/* 0x006C */ s32 viTvType;
/* 0x0070 */ u32 unk_70; // bool
/* 0x0074 */ u32 unk_74; // bool
/* 0x0078 */ u32 unk_78; // bool
/* 0x007C */ u32 unk_7C; // bool
/* 0x0080 */ u32 viFeatures;
/* 0x0084 */ u32 unk_84;
};
#endif

4
include/unk.h
View File

@ -7,8 +7,8 @@
#define UNK_TYPE4 s32
#define UNK_PTR void*
#define UNK_RET void
#define UNK_FUN_ARG void(*)(void)
#define UNK_FUN_PTR(name) void(*name)(void)
#define UNK_FUN_ARG void (*)(void)
#define UNK_FUN_PTR(name) void (*name)(void)
#define UNK_ARGS
#define UNK_SIZE 1
#define UNK_LINE 1

64
include/view.h
View File

@ -1,37 +1,39 @@
#pragma once
#include "ultra64/gbi.h"
#include "ultra64/types.h"
#include "z64math.h"
#include "ultra64/gbi.h"
struct Viewport {
/* 0x0000 */ s32 topY; // uly (upper left y)
/* 0x0004 */ s32 bottomY; // lry (lower right y)
/* 0x0008 */ s32 leftX; // ulx (upper left x)
/* 0x000C */ s32 rightX; // lrx (lower right x)
}; // size = 0x10
struct Viewport
{
/* 0x0000 */ s32 topY; // uly (upper left y)
/* 0x0004 */ s32 bottomY; // lry (lower right y)
/* 0x0008 */ s32 leftX; // ulx (upper left x)
/* 0x000C */ s32 rightX; // lrx (lower right x)
}; // size = 0x10
struct View {
/* 0x0000 */ s32 magic; // string literal "VIEW" / 0x56494557
/* 0x0004 */ struct GraphicsContext* gfxCtx;
/* 0x0008 */ Viewport viewport;
/* 0x0018 */ f32 fovy; // vertical field of view in degrees
/* 0x001C */ f32 zNear; // distance to near clipping plane
/* 0x0020 */ f32 zFar; // distance to far clipping plane
/* 0x0024 */ f32 scale; // scale for matrix elements
/* 0x0028 */ Vec3f eye;
/* 0x0034 */ Vec3f lookAt;
/* 0x0040 */ Vec3f up;
/* 0x0050 */ Vp vp;
/* 0x0060 */ Mtx projection;
/* 0x00A0 */ Mtx viewing;
/* 0x00E0 */ Mtx* projectionPtr;
/* 0x00E4 */ Mtx* viewingPtr;
/* 0x00E8 */ Vec3f unk_E8;
/* 0x00F4 */ Vec3f unk_F4;
/* 0x0100 */ f32 unk_100;
/* 0x0104 */ Vec3f unk_104;
/* 0x0110 */ Vec3f unk_110;
/* 0x011C */ u16 normal; // used to normalize the projection matrix
/* 0x0120 */ s32 flags;
/* 0x0124 */ s32 unk_124;
struct View
{
/* 0x0000 */ s32 magic; // string literal "VIEW" / 0x56494557
/* 0x0004 */ struct GraphicsContext* gfxCtx;
/* 0x0008 */ Viewport viewport;
/* 0x0018 */ f32 fovy; // vertical field of view in degrees
/* 0x001C */ f32 zNear; // distance to near clipping plane
/* 0x0020 */ f32 zFar; // distance to far clipping plane
/* 0x0024 */ f32 scale; // scale for matrix elements
/* 0x0028 */ Vec3f eye;
/* 0x0034 */ Vec3f lookAt;
/* 0x0040 */ Vec3f up;
/* 0x0050 */ Vp vp;
/* 0x0060 */ Mtx projection;
/* 0x00A0 */ Mtx viewing;
/* 0x00E0 */ Mtx* projectionPtr;
/* 0x00E4 */ Mtx* viewingPtr;
/* 0x00E8 */ Vec3f unk_E8;
/* 0x00F4 */ Vec3f unk_F4;
/* 0x0100 */ f32 unk_100;
/* 0x0104 */ Vec3f unk_104;
/* 0x0110 */ Vec3f unk_110;
/* 0x011C */ u16 normal; // used to normalize the projection matrix
/* 0x0120 */ s32 flags;
/* 0x0124 */ s32 unk_124;
}; // size = 0x128

30
include/vt.h
View File

@ -1,23 +1,23 @@
#ifndef VT_H
#define VT_H
#define VT_COLOR_BLACK 0
#define VT_COLOR_RED 1
#define VT_COLOR_GREEN 2
#define VT_COLOR_YELLOW 3
#define VT_COLOR_BLUE 4
#define VT_COLOR_PURPLE 5
#define VT_COLOR_CYAN 6
#define VT_COLOR_WHITE 7
#define VT_COLOR_LIGHTGRAY 8
#define VT_COLOR_DARKGRAY 9
#define VT_COLOR_BLACK 0
#define VT_COLOR_RED 1
#define VT_COLOR_GREEN 2
#define VT_COLOR_YELLOW 3
#define VT_COLOR_BLUE 4
#define VT_COLOR_PURPLE 5
#define VT_COLOR_CYAN 6
#define VT_COLOR_WHITE 7
#define VT_COLOR_LIGHTGRAY 8
#define VT_COLOR_DARKGRAY 9
#define VT_COLOR_FOREGROUND 3
#define VT_COLOR_BACKGROUND 4
#define VT_COLOR_FOREGROUND 3
#define VT_COLOR_BACKGROUND 4
#define VT_COLOR_EXPAND0(type, color) #type #color
#define VT_COLOR_EXPAND1(type, color) VT_COLOR_EXPAND0(type, color)
#define VT_COLOR(type, color) VT_COLOR_EXPAND1(VT_COLOR_##type, VT_COLOR_##color)
#define VT_COLOR_EXPAND0(type, color) #type #color
#define VT_COLOR_EXPAND1(type, color) VT_COLOR_EXPAND0(type, color)
#define VT_COLOR(type, color) VT_COLOR_EXPAND1(VT_COLOR_##type, VT_COLOR_##color)
#define VT_ESC "\x1b"
#define VT_CSI "["

111
include/z64.h
View File

@ -3,7 +3,7 @@
#include "global.h"
#include "ultra64/types.h"
#define SCREEN_WIDTH 320
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 240
#define REGION_NULL 0
@ -24,74 +24,75 @@
// NOTE: Once we start supporting other builds, this can be changed with an ifdef
#define REGION_NATIVE REGION_EU
struct SequenceContext {
/* 0x00 */ u8 seqId;
/* 0x01 */ u8 natureAmbienceId;
struct SequenceContext
{
/* 0x00 */ u8 seqId;
/* 0x01 */ u8 natureAmbienceId;
}; // size = 0x2
struct ElfMessage {
/* 0x00 */ u8 byte0;
/* 0x01 */ u8 byte1;
/* 0x02 */ u8 byte2;
/* 0x03 */ u8 byte3;
struct ElfMessage
{
/* 0x00 */ u8 byte0;
/* 0x01 */ u8 byte1;
/* 0x02 */ u8 byte2;
/* 0x03 */ u8 byte3;
}; // size = 0x4
struct StackEntry {
/* 0x00 */ struct StackEntry* next;
/* 0x04 */ struct StackEntry* prev;
/* 0x08 */ uintptr_t head;
/* 0x0C */ uintptr_t tail;
/* 0x10 */ u32 initValue;
/* 0x14 */ s32 minSpace;
/* 0x18 */ const char* name;
struct StackEntry
{
/* 0x00 */ struct StackEntry* next;
/* 0x04 */ struct StackEntry* prev;
/* 0x08 */ uintptr_t head;
/* 0x0C */ uintptr_t tail;
/* 0x10 */ u32 initValue;
/* 0x14 */ s32 minSpace;
/* 0x18 */ const char* name;
};
enum StackStatus {
STACK_STATUS_OK = 0,
STACK_STATUS_WARNING = 1,
STACK_STATUS_OVERFLOW = 2
enum StackStatus
{
STACK_STATUS_OK = 0,
STACK_STATUS_WARNING = 1,
STACK_STATUS_OVERFLOW = 2
};
struct ISVDbg {
/* 0x00 */ u32 magic; // IS64
/* 0x04 */ u32 get;
/* 0x08 */ u8 unk_08[0x14-0x08];
/* 0x14 */ u32 put;
/* 0x18 */ u8 unk_18[0x20-0x18];
/* 0x20 */ u8 data[0x10000-0x20];
struct ISVDbg
{
/* 0x00 */ u32 magic; // IS64
/* 0x04 */ u32 get;
/* 0x08 */ u8 unk_08[0x14 - 0x08];
/* 0x14 */ u32 put;
/* 0x18 */ u8 unk_18[0x20 - 0x18];
/* 0x20 */ u8 data[0x10000 - 0x20];
};
typedef struct {
/* 0x00 */ char name[0x18];
/* 0x18 */ u32 mediaFormat;
/* 0x1C */ union {
struct {
u16 cartId;
u8 countryCode;
u8 version;
};
u32 regionInfo;
};
typedef struct
{
/* 0x00 */ char name[0x18];
/* 0x18 */ u32 mediaFormat;
/* 0x1C */ union
{
struct
{
u16 cartId;
u8 countryCode;
u8 version;
};
u32 regionInfo;
};
} LocaleCartInfo; // size = 0x20
// ========================
struct OverlayRelocationSection {
/* 0x00 */ u32 textSize;
/* 0x04 */ u32 dataSize;
/* 0x08 */ u32 rodataSize;
/* 0x0C */ u32 bssSize;
/* 0x10 */ u32 nRelocations;
/* 0x14 */ u32 relocations[1];
struct OverlayRelocationSection
{
/* 0x00 */ u32 textSize;
/* 0x04 */ u32 dataSize;
/* 0x08 */ u32 rodataSize;
/* 0x0C */ u32 bssSize;
/* 0x10 */ u32 nRelocations;
/* 0x14 */ u32 relocations[1];
}; // size >= 0x18
#define NUM_SEGMENTS (16)
#define NUM_SEGMENTS (16)
extern uintptr_t gSegments[NUM_SEGMENTS];

674
include/z64actor.h
View File

@ -1,24 +1,26 @@
#pragma once
#include "z64dma.h"
#include "z64animation.h"
#include "z64math.h"
#include "z64collision_check.h"
#include "color.h"
#include "framerate.h"
#include "z64animation.h"
#include "z64collision_check.h"
#include "z64dma.h"
#include "z64math.h"
union Gfx;
#define ACTOR_NUMBER_MAX 200
#define INVISIBLE_ACTOR_MAX 20
#define AM_FIELD_SIZE 0x27A0
#define MASS_IMMOVABLE 0xFF // Cannot be pushed by OC collisions
#define MASS_HEAVY 0xFE // Can only be pushed by OC collisions with IMMOVABLE and HEAVY objects.
#define MASS_HEAVY 0xFE // Can only be pushed by OC collisions with IMMOVABLE and HEAVY objects.
enum DynaPolyMoveFlag
{
DPM_UNK = 0,
DPM_PLAYER = 1,
DPM_ENEMY = 2,
DPM_UNK3 = 3
DPM_UNK = 0,
DPM_PLAYER = 1,
DPM_ENEMY = 2,
DPM_UNK3 = 3
};
struct Actor;
@ -30,94 +32,101 @@ typedef void (*ActorShadowFunc)(struct Actor*, struct Lights*, struct GlobalCont
typedef u16 (*callback1_800343CC)(struct GlobalContext*, struct Actor*);
typedef s16 (*callback2_800343CC)(struct GlobalContext*, struct Actor*);
struct ActorEntry {
/* 0x00 */ s16 id;
/* 0x02 */ Vec3s pos;
/* 0x08 */ Vec3s rot;
/* 0x0E */ s16 params;
struct ActorEntry
{
/* 0x00 */ s16 id;
/* 0x02 */ Vec3s pos;
/* 0x08 */ Vec3s rot;
/* 0x0E */ s16 params;
}; // size = 0x10
struct ActorInit {
struct ActorInit
{
constexpr ActorInit(s16 id, u8 category, u32 flags, s16 objectId, u32 instanceSize, ActorFunc init, ActorFunc destroy, ActorFunc update, ActorFunc draw, ActorFunc reset) :
id(id), category(category), flags(flags), objectId(objectId), instanceSize(instanceSize), init(init), destroy(destroy), update(update), draw(draw), reset(reset)
{
}
/* 0x00 */ s16 id;
/* 0x02 */ u8 category; // Classifies actor and determines when it will update or draw
/* 0x04 */ u32 flags;
/* 0x08 */ s16 objectId;
/* 0x0C */ u32 instanceSize;
/* 0x10 */ ActorFunc init; // Constructor
/* 0x14 */ ActorFunc destroy; // Destructor
/* 0x18 */ ActorFunc update; // Update Function
/* 0x1C */ ActorFunc draw; // Draw function
ActorFunc reset; // Reset function
}; // size = 0x20
/* 0x00 */ s16 id;
/* 0x02 */ u8 category; // Classifies actor and determines when it will update or draw
/* 0x04 */ u32 flags;
/* 0x08 */ s16 objectId;
/* 0x0C */ u32 instanceSize;
/* 0x10 */ ActorFunc init; // Constructor
/* 0x14 */ ActorFunc destroy; // Destructor
/* 0x18 */ ActorFunc update; // Update Function
/* 0x1C */ ActorFunc draw; // Draw function
ActorFunc reset; // Reset function
}; // size = 0x20
enum AllocType
{
/* 0 */ ALLOCTYPE_NORMAL,
/* 1 */ ALLOCTYPE_ABSOLUTE,
/* 2 */ ALLOCTYPE_PERMANENT
/* 0 */ ALLOCTYPE_NORMAL,
/* 1 */ ALLOCTYPE_ABSOLUTE,
/* 2 */ ALLOCTYPE_PERMANENT
};
struct ActorOverlay {
/* 0x00 */ Pointer vromStart;
/* 0x04 */ Pointer vromEnd;
/* 0x08 */ Pointer vramStart;
/* 0x0C */ Pointer vramEnd;
/* 0x10 */ Pointer loadedRamAddr; // original name: "allocp"
/* 0x14 */ ActorInit* initInfo;
/* 0x18 */ const char* name;
/* 0x1C */ u16 allocType;
/* 0x1E */ s8 numLoaded; // original name: "clients"
}; // size = 0x20
struct ActorOverlay
{
/* 0x00 */ Pointer vromStart;
/* 0x04 */ Pointer vromEnd;
/* 0x08 */ Pointer vramStart;
/* 0x0C */ Pointer vramEnd;
/* 0x10 */ Pointer loadedRamAddr; // original name: "allocp"
/* 0x14 */ ActorInit* initInfo;
/* 0x18 */ const char* name;
/* 0x1C */ u16 allocType;
/* 0x1E */ s8 numLoaded; // original name: "clients"
}; // size = 0x20
struct DamageTable
{
u8 table[32];
u8 table[32];
};
struct CollisionCheckInfoInit {
/* 0x00 */ u8 health;
/* 0x02 */ s16 cylRadius;
/* 0x04 */ s16 cylHeight;
/* 0x06 */ u8 mass;
struct CollisionCheckInfoInit
{
/* 0x00 */ u8 health;
/* 0x02 */ s16 cylRadius;
/* 0x04 */ s16 cylHeight;
/* 0x06 */ u8 mass;
};
struct CollisionCheckInfoInit2 {
/* 0x00 */ u8 health;
/* 0x02 */ s16 cylRadius;
/* 0x04 */ s16 cylHeight;
/* 0x06 */ s16 cylYShift;
/* 0x08 */ u8 mass;
struct CollisionCheckInfoInit2
{
/* 0x00 */ u8 health;
/* 0x02 */ s16 cylRadius;
/* 0x04 */ s16 cylHeight;
/* 0x06 */ s16 cylYShift;
/* 0x08 */ u8 mass;
};
struct CollisionCheckInfo {
/* 0x00 */ DamageTable* damageTable;
/* 0x04 */ Vec3f displacement; // Amount to correct velocity (0x5C) by when colliding into a body
/* 0x10 */ s16 cylRadius; // Used for various purposes
/* 0x12 */ s16 cylHeight; // Used for various purposes
/* 0x14 */ s16 cylYShift; // Unused. Purpose inferred from Cylinder16 and CollisionCheck_CylSideVsLineSeg
/* 0x16 */ u8 mass; // Used to compute displacement for OC collisions
/* 0x17 */ u8 health; // Note: some actors may use their own health variable instead of this one
/* 0x18 */ u8 damage; // Amount to decrement health by
/* 0x19 */ u8 damageEffect; // Stores what effect should occur when hit by a weapon
/* 0x1A */ u8 atHitEffect; // Stores what effect should occur when AT connects with an AC
/* 0x1B */ u8 acHitEffect; // Stores what effect should occur when AC is touched by an AT
}; // size = 0x1C
struct CollisionCheckInfo
{
/* 0x00 */ DamageTable* damageTable;
/* 0x04 */ Vec3f displacement; // Amount to correct velocity (0x5C) by when colliding into a body
/* 0x10 */ s16 cylRadius; // Used for various purposes
/* 0x12 */ s16 cylHeight; // Used for various purposes
/* 0x14 */ s16 cylYShift; // Unused. Purpose inferred from Cylinder16 and CollisionCheck_CylSideVsLineSeg
/* 0x16 */ u8 mass; // Used to compute displacement for OC collisions
/* 0x17 */ u8 health; // Note: some actors may use their own health variable instead of this one
/* 0x18 */ u8 damage; // Amount to decrement health by
/* 0x19 */ u8 damageEffect; // Stores what effect should occur when hit by a weapon
/* 0x1A */ u8 atHitEffect; // Stores what effect should occur when AT connects with an AC
/* 0x1B */ u8 acHitEffect; // Stores what effect should occur when AC is touched by an AT
}; // size = 0x1C
struct ActorShape {
/* 0x00 */ VecRot rot; // Current actor shape rotation
/* 0x06 */ s16 face; // Used to index eyebrow/eye/mouth textures. Only used by player
/* 0x08 */ f32 yOffset; // Model y axis offset. Represents model space units
/* 0x0C */ ActorShadowFunc shadowDraw; // Shadow draw function
/* 0x10 */ f32 shadowScale; // Changes the size of the shadow
/* 0x14 */ u8 shadowAlpha; // Default is 255
/* 0x15 */ u8 feetFloorFlags; // Set if the actor's foot is clipped under the floor. & 1 is right foot, & 2 is left
/* 0x18 */ Vec3f feetPos[2]; // Update by using `Actor_SetFeetPos` in PostLimbDraw
}; // size = 0x30
struct ActorShape
{
/* 0x00 */ VecRot rot; // Current actor shape rotation
/* 0x06 */ s16 face; // Used to index eyebrow/eye/mouth textures. Only used by player
/* 0x08 */ f32 yOffset; // Model y axis offset. Represents model space units
/* 0x0C */ ActorShadowFunc shadowDraw; // Shadow draw function
/* 0x10 */ f32 shadowScale; // Changes the size of the shadow
/* 0x14 */ u8 shadowAlpha; // Default is 255
/* 0x15 */ u8 feetFloorFlags; // Set if the actor's foot is clipped under the floor. & 1 is right foot, & 2 is left
/* 0x18 */ Vec3f feetPos[2]; // Update by using `Actor_SetFeetPos` in PostLimbDraw
}; // size = 0x30
#define ACTOR_FLAG_0 (1 << 0)
#define ACTOR_FLAG_2 (1 << 2)
@ -148,69 +157,70 @@ struct ActorShape {
#define ACTOR_FLAG_27 (1 << 27)
#define ACTOR_FLAG_28 (1 << 28)
struct Actor {
/* 0x000 */ s16 id; // Actor ID
/* 0x002 */ u8 category; // Actor category. Refer to the corresponding enum for values
/* 0x003 */ s8 room; // Room number the actor is in. -1 denotes that the actor won't despawn on a room change
/* 0x004 */ u32 flags; // Flags used for various purposes
/* 0x008 */ PosRot home; // Initial position/rotation when spawned. Can be used for other purposes
/* 0x01C */ s16 params; // Configurable variable set by the actor's spawn data; original name: "args_data"
/* 0x01E */ s32 objBankIndex; // Object bank index of the actor's object dependency; original name: "bank"
/* 0x01F */ s8 targetMode; // Controls how far the actor can be targeted from and how far it can stay locked on
/* 0x020 */ u16 sfx; // SFX ID to play. Sound plays when value is set, then is cleared the following update cycle
/* 0x024 */ PosRot world; // Position/rotation in the world
/* 0x038 */ PosRot focus; // Target reticle focuses on this position. For player this represents head pos and rot
/* 0x04C */ f32 targetArrowOffset; // Height offset of the target arrow relative to `focus` position
/* 0x050 */ Vec3f scale; // Scale of the actor in each axis
/* 0x05C */ Vec3f velocity; // Velocity of the actor in each axis
/* 0x068 */ f32 speedXZ; // How fast the actor is traveling along the XZ plane
/* 0x06C */ f32 gravity; // Acceleration due to gravity. Value is added to Y velocity every frame
/* 0x070 */ f32 minVelocityY; // Sets the lower bounds cap on velocity along the Y axis
/* 0x074 */ struct CollisionPoly* wallPoly; // Wall polygon the actor is touching
/* 0x078 */ struct CollisionPoly* floorPoly; // Floor polygon directly below the actor
/* 0x07C */ u8 wallBgId; // Bg ID of the wall polygon the actor is touching
/* 0x07D */ u8 floorBgId; // Bg ID of the floor polygon directly below the actor
/* 0x07E */ s16 wallYaw; // Y rotation of the wall polygon the actor is touching
/* 0x080 */ f32 floorHeight; // Y position of the floor polygon directly below the actor
/* 0x084 */ f32 yDistToWater; // Distance to the surface of active waterbox. Negative value means above water
/* 0x088 */ u16 bgCheckFlags; // See comments below actor struct for wip docs. TODO: macros for these flags
/* 0x08A */ s16 yawTowardsPlayer; // Y rotation difference between the actor and the player
/* 0x08C */ f32 xyzDistToPlayerSq; // Squared distance between the actor and the player in the x,y,z axis
/* 0x090 */ f32 xzDistToPlayer; // Distance between the actor and the player in the XZ plane
/* 0x094 */ f32 yDistToPlayer; // Dist is negative if the actor is above the player
/* 0x098 */ CollisionCheckInfo colChkInfo; // Variables related to the Collision Check system
/* 0x0B4 */ ActorShape shape; // Variables related to the physical shape of the actor
/* 0x0E4 */ Vec3f projectedPos; // Position of the actor in projected space
/* 0x0F0 */ f32 projectedW; // w component of the projected actor position
/* 0x0F4 */ f32 uncullZoneForward; // Amount to increase the uncull zone forward by (in projected space)
/* 0x0F8 */ f32 uncullZoneScale; // Amount to increase the uncull zone scale by (in projected space)
/* 0x0FC */ f32 uncullZoneDownward; // Amount to increase uncull zone downward by (in projected space)
/* 0x100 */ Vec3f prevPos; // World position from the previous update cycle
/* 0x10C */ u8 isTargeted; // Set to true if the actor is currently being targeted by the player
/* 0x10D */ u8 targetPriority; // Lower values have higher priority. Resets to 0 when player stops targeting
/* 0x10E */ u16 textId; // Text ID to pass to link/display when interacting with the actor
/* 0x110 */ Timer freezeTimer; // Actor does not update when set. Timer decrements automatically
/* 0x112 */ u16 colorFilterParams; // Set color filter to red, blue, or white. Toggle opa or xlu
/* 0x114 */ u8 colorFilterTimer; // A non-zero value enables the color filter. Decrements automatically
/* 0x115 */ u8 isDrawn; // Set to true if the actor is currently being drawn. Always stays false for lens actors
/* 0x116 */ u8 dropFlag; // Configures what item is dropped by the actor from `Item_DropCollectibleRandom`
/* 0x117 */ u8 naviEnemyId; // Sets what 0600 dialog to display when talking to navi. Default 0xFF
/* 0x118 */ struct Actor* parent; // Usage is actor specific. Set if actor is spawned via `Actor_SpawnAsChild`
/* 0x11C */ struct Actor* child; // Usage is actor specific. Set if actor is spawned via `Actor_SpawnAsChild`
/* 0x120 */ struct Actor* prev; // Previous actor of this category
/* 0x124 */ struct Actor* next; // Next actor of this category
/* 0x128 */ ActorFunc init; // Initialization Routine. Called by `Actor_Init` or `Actor_UpdateAll`
/* 0x12C */ ActorFunc destroy; // Destruction Routine. Called by `Actor_Destroy`
/* 0x130 */ ActorFunc update; // Update Routine. Called by `Actor_UpdateAll`
/* 0x134 */ ActorFunc draw; // Draw Routine. Called by `Actor_Draw`
/* 0x138 */ ActorOverlay* overlayEntry; // Pointer to the overlay table entry for this actor
/* 0x13C */ char dbgPad[0x10]; // Padding that only exists in the debug rom
}; // size = 0x14C
struct Actor
{
/* 0x000 */ s16 id; // Actor ID
/* 0x002 */ u8 category; // Actor category. Refer to the corresponding enum for values
/* 0x003 */ s8 room; // Room number the actor is in. -1 denotes that the actor won't despawn on a room change
/* 0x004 */ u32 flags; // Flags used for various purposes
/* 0x008 */ PosRot home; // Initial position/rotation when spawned. Can be used for other purposes
/* 0x01C */ s16 params; // Configurable variable set by the actor's spawn data; original name: "args_data"
/* 0x01E */ s32 objBankIndex; // Object bank index of the actor's object dependency; original name: "bank"
/* 0x01F */ s8 targetMode; // Controls how far the actor can be targeted from and how far it can stay locked on
/* 0x020 */ u16 sfx; // SFX ID to play. Sound plays when value is set, then is cleared the following update cycle
/* 0x024 */ PosRot world; // Position/rotation in the world
/* 0x038 */ PosRot focus; // Target reticle focuses on this position. For player this represents head pos and rot
/* 0x04C */ f32 targetArrowOffset; // Height offset of the target arrow relative to `focus` position
/* 0x050 */ Vec3f scale; // Scale of the actor in each axis
/* 0x05C */ Vec3f velocity; // Velocity of the actor in each axis
/* 0x068 */ f32 speedXZ; // How fast the actor is traveling along the XZ plane
/* 0x06C */ f32 gravity; // Acceleration due to gravity. Value is added to Y velocity every frame
/* 0x070 */ f32 minVelocityY; // Sets the lower bounds cap on velocity along the Y axis
/* 0x074 */ struct CollisionPoly* wallPoly; // Wall polygon the actor is touching
/* 0x078 */ struct CollisionPoly* floorPoly; // Floor polygon directly below the actor
/* 0x07C */ u8 wallBgId; // Bg ID of the wall polygon the actor is touching
/* 0x07D */ u8 floorBgId; // Bg ID of the floor polygon directly below the actor
/* 0x07E */ s16 wallYaw; // Y rotation of the wall polygon the actor is touching
/* 0x080 */ f32 floorHeight; // Y position of the floor polygon directly below the actor
/* 0x084 */ f32 yDistToWater; // Distance to the surface of active waterbox. Negative value means above water
/* 0x088 */ u16 bgCheckFlags; // See comments below actor struct for wip docs. TODO: macros for these flags
/* 0x08A */ s16 yawTowardsPlayer; // Y rotation difference between the actor and the player
/* 0x08C */ f32 xyzDistToPlayerSq; // Squared distance between the actor and the player in the x,y,z axis
/* 0x090 */ f32 xzDistToPlayer; // Distance between the actor and the player in the XZ plane
/* 0x094 */ f32 yDistToPlayer; // Dist is negative if the actor is above the player
/* 0x098 */ CollisionCheckInfo colChkInfo; // Variables related to the Collision Check system
/* 0x0B4 */ ActorShape shape; // Variables related to the physical shape of the actor
/* 0x0E4 */ Vec3f projectedPos; // Position of the actor in projected space
/* 0x0F0 */ f32 projectedW; // w component of the projected actor position
/* 0x0F4 */ f32 uncullZoneForward; // Amount to increase the uncull zone forward by (in projected space)
/* 0x0F8 */ f32 uncullZoneScale; // Amount to increase the uncull zone scale by (in projected space)
/* 0x0FC */ f32 uncullZoneDownward; // Amount to increase uncull zone downward by (in projected space)
/* 0x100 */ Vec3f prevPos; // World position from the previous update cycle
/* 0x10C */ u8 isTargeted; // Set to true if the actor is currently being targeted by the player
/* 0x10D */ u8 targetPriority; // Lower values have higher priority. Resets to 0 when player stops targeting
/* 0x10E */ u16 textId; // Text ID to pass to link/display when interacting with the actor
/* 0x110 */ Timer freezeTimer; // Actor does not update when set. Timer decrements automatically
/* 0x112 */ u16 colorFilterParams; // Set color filter to red, blue, or white. Toggle opa or xlu
/* 0x114 */ u8 colorFilterTimer; // A non-zero value enables the color filter. Decrements automatically
/* 0x115 */ u8 isDrawn; // Set to true if the actor is currently being drawn. Always stays false for lens actors
/* 0x116 */ u8 dropFlag; // Configures what item is dropped by the actor from `Item_DropCollectibleRandom`
/* 0x117 */ u8 naviEnemyId; // Sets what 0600 dialog to display when talking to navi. Default 0xFF
/* 0x118 */ struct Actor* parent; // Usage is actor specific. Set if actor is spawned via `Actor_SpawnAsChild`
/* 0x11C */ struct Actor* child; // Usage is actor specific. Set if actor is spawned via `Actor_SpawnAsChild`
/* 0x120 */ struct Actor* prev; // Previous actor of this category
/* 0x124 */ struct Actor* next; // Next actor of this category
/* 0x128 */ ActorFunc init; // Initialization Routine. Called by `Actor_Init` or `Actor_UpdateAll`
/* 0x12C */ ActorFunc destroy; // Destruction Routine. Called by `Actor_Destroy`
/* 0x130 */ ActorFunc update; // Update Routine. Called by `Actor_UpdateAll`
/* 0x134 */ ActorFunc draw; // Draw Routine. Called by `Actor_Draw`
/* 0x138 */ ActorOverlay* overlayEntry; // Pointer to the overlay table entry for this actor
/* 0x13C */ char dbgPad[0x10]; // Padding that only exists in the debug rom
}; // size = 0x14C
enum ActorFootIndex
{
/* 0 */ FOOT_LEFT,
/* 1 */ FOOT_RIGHT
/* 0 */ FOOT_LEFT,
/* 1 */ FOOT_RIGHT
};
/*
@ -237,25 +247,27 @@ if neither of the above are set : blue
0x2000 : translucent, else opaque
*/
struct DynaPolyActor {
/* 0x000 */ struct Actor actor;
/* 0x14C */ s32 bgId;
/* 0x150 */ f32 unk_150;
/* 0x154 */ f32 unk_154;
/* 0x158 */ s16 unk_158; // y rotation?
/* 0x15A */ u16 unk_15A;
/* 0x15C */ u32 unk_15C;
/* 0x160 */ u8 unk_160;
/* 0x162 */ s16 unk_162;
struct DynaPolyActor
{
/* 0x000 */ struct Actor actor;
/* 0x14C */ s32 bgId;
/* 0x150 */ f32 unk_150;
/* 0x154 */ f32 unk_154;
/* 0x158 */ s16 unk_158; // y rotation?
/* 0x15A */ u16 unk_15A;
/* 0x15C */ u32 unk_15C;
/* 0x160 */ u8 unk_160;
/* 0x162 */ s16 unk_162;
}; // size = 0x164
struct BodyBreak {
/* 0x00 */ MtxF* matrices;
/* 0x04 */ s16* objectIds;
/* 0x08 */ s16 count;
/* 0x0C */ Gfx** dLists;
/* 0x10 */ s32 val; // used for various purposes: both a status indicator and counter
/* 0x14 */ s32 prevLimbIndex;
struct BodyBreak
{
/* 0x00 */ MtxF* matrices;
/* 0x04 */ s16* objectIds;
/* 0x08 */ s16 count;
/* 0x0C */ Gfx** dLists;
/* 0x10 */ s32 val; // used for various purposes: both a status indicator and counter
/* 0x14 */ s32 prevLimbIndex;
};
#define BODYBREAK_OBJECT_DEFAULT -1 // use the same object as the actor
@ -264,240 +276,251 @@ struct BodyBreak {
enum Item00Type
{
/* 0x00 */ ITEM00_RUPEE_GREEN,
/* 0x01 */ ITEM00_RUPEE_BLUE,
/* 0x02 */ ITEM00_RUPEE_RED,
/* 0x03 */ ITEM00_HEART,
/* 0x04 */ ITEM00_BOMBS_A,
/* 0x05 */ ITEM00_ARROWS_SINGLE,
/* 0x06 */ ITEM00_HEART_PIECE,
/* 0x07 */ ITEM00_HEART_CONTAINER,
/* 0x08 */ ITEM00_ARROWS_SMALL,
/* 0x09 */ ITEM00_ARROWS_MEDIUM,
/* 0x0A */ ITEM00_ARROWS_LARGE,
/* 0x0B */ ITEM00_BOMBS_B,
/* 0x0C */ ITEM00_NUTS,
/* 0x0D */ ITEM00_STICK,
/* 0x0E */ ITEM00_MAGIC_LARGE,
/* 0x0F */ ITEM00_MAGIC_SMALL,
/* 0x10 */ ITEM00_SEEDS,
/* 0x11 */ ITEM00_SMALL_KEY,
/* 0x12 */ ITEM00_FLEXIBLE,
/* 0x13 */ ITEM00_RUPEE_ORANGE,
/* 0x14 */ ITEM00_RUPEE_PURPLE,
/* 0x15 */ ITEM00_SHIELD_DEKU,
/* 0x16 */ ITEM00_SHIELD_HYLIAN,
/* 0x17 */ ITEM00_TUNIC_ZORA,
/* 0x18 */ ITEM00_TUNIC_GORON,
/* 0x19 */ ITEM00_BOMBS_SPECIAL
/* 0x00 */ ITEM00_RUPEE_GREEN,
/* 0x01 */ ITEM00_RUPEE_BLUE,
/* 0x02 */ ITEM00_RUPEE_RED,
/* 0x03 */ ITEM00_HEART,
/* 0x04 */ ITEM00_BOMBS_A,
/* 0x05 */ ITEM00_ARROWS_SINGLE,
/* 0x06 */ ITEM00_HEART_PIECE,
/* 0x07 */ ITEM00_HEART_CONTAINER,
/* 0x08 */ ITEM00_ARROWS_SMALL,
/* 0x09 */ ITEM00_ARROWS_MEDIUM,
/* 0x0A */ ITEM00_ARROWS_LARGE,
/* 0x0B */ ITEM00_BOMBS_B,
/* 0x0C */ ITEM00_NUTS,
/* 0x0D */ ITEM00_STICK,
/* 0x0E */ ITEM00_MAGIC_LARGE,
/* 0x0F */ ITEM00_MAGIC_SMALL,
/* 0x10 */ ITEM00_SEEDS,
/* 0x11 */ ITEM00_SMALL_KEY,
/* 0x12 */ ITEM00_FLEXIBLE,
/* 0x13 */ ITEM00_RUPEE_ORANGE,
/* 0x14 */ ITEM00_RUPEE_PURPLE,
/* 0x15 */ ITEM00_SHIELD_DEKU,
/* 0x16 */ ITEM00_SHIELD_HYLIAN,
/* 0x17 */ ITEM00_TUNIC_ZORA,
/* 0x18 */ ITEM00_TUNIC_GORON,
/* 0x19 */ ITEM00_BOMBS_SPECIAL
};
struct EnItem00;
typedef void (*EnItem00ActionFunc)(struct EnItem00*, struct GlobalContext*);
struct EnItem00 {
/* 0x000 */ Actor actor;
/* 0x14C */ EnItem00ActionFunc actionFunc;
/* 0x150 */ s16 collectibleFlag;
/* 0x152 */ s16 getItemId;
/* 0x154 */ s16 unk_154;
/* 0x156 */ s16 unk_156;
/* 0x158 */ s16 unk_158;
/* 0x15A */ s16 unk_15A;
/* 0x15C */ f32 scale;
/* 0x160 */ ColliderCylinder collider;
struct EnItem00
{
/* 0x000 */ Actor actor;
/* 0x14C */ EnItem00ActionFunc actionFunc;
/* 0x150 */ s16 collectibleFlag;
/* 0x152 */ s16 getItemId;
/* 0x154 */ s16 unk_154;
/* 0x156 */ s16 unk_156;
/* 0x158 */ s16 unk_158;
/* 0x15A */ s16 unk_15A;
/* 0x15C */ f32 scale;
/* 0x160 */ ColliderCylinder collider;
}; // size = 0x1AC
// Only A_OBJ_SIGNPOST_OBLONG and A_OBJ_SIGNPOST_ARROW are used in room files.
enum AObjType
{
/* 0x00 */ A_OBJ_BLOCK_SMALL,
/* 0x01 */ A_OBJ_BLOCK_LARGE,
/* 0x02 */ A_OBJ_BLOCK_HUGE,
/* 0x03 */ A_OBJ_BLOCK_SMALL_ROT,
/* 0x04 */ A_OBJ_BLOCK_LARGE_ROT,
/* 0x05 */ A_OBJ_CUBE_SMALL,
/* 0x06 */ A_OBJ_UNKNOWN_6,
/* 0x07 */ A_OBJ_GRASS_CLUMP,
/* 0x08 */ A_OBJ_TREE_STUMP,
/* 0x09 */ A_OBJ_SIGNPOST_OBLONG,
/* 0x0A */ A_OBJ_SIGNPOST_ARROW,
/* 0x0B */ A_OBJ_BOULDER_FRAGMENT,
/* 0x0C */ A_OBJ_MAX
/* 0x00 */ A_OBJ_BLOCK_SMALL,
/* 0x01 */ A_OBJ_BLOCK_LARGE,
/* 0x02 */ A_OBJ_BLOCK_HUGE,
/* 0x03 */ A_OBJ_BLOCK_SMALL_ROT,
/* 0x04 */ A_OBJ_BLOCK_LARGE_ROT,
/* 0x05 */ A_OBJ_CUBE_SMALL,
/* 0x06 */ A_OBJ_UNKNOWN_6,
/* 0x07 */ A_OBJ_GRASS_CLUMP,
/* 0x08 */ A_OBJ_TREE_STUMP,
/* 0x09 */ A_OBJ_SIGNPOST_OBLONG,
/* 0x0A */ A_OBJ_SIGNPOST_ARROW,
/* 0x0B */ A_OBJ_BOULDER_FRAGMENT,
/* 0x0C */ A_OBJ_MAX
};
struct EnAObj;
typedef void (*EnAObjActionFunc)(struct EnAObj*, struct GlobalContext*);
struct EnAObj {
/* 0x000 */ DynaPolyActor dyna;
/* 0x164 */ EnAObjActionFunc actionFunc;
/* 0x168 */ s32 rotateWaitTimer;
/* 0x16C */ s16 textId;
/* 0x16E */ s16 rotateState;
/* 0x170 */ s16 rotateForTimer;
/* 0x172 */ s16 rotSpeedY;
/* 0x174 */ s16 rotSpeedX;
/* 0x178 */ f32 focusYoffset;
/* 0x17C */ ColliderCylinder collider;
struct EnAObj
{
/* 0x000 */ DynaPolyActor dyna;
/* 0x164 */ EnAObjActionFunc actionFunc;
/* 0x168 */ s32 rotateWaitTimer;
/* 0x16C */ s16 textId;
/* 0x16E */ s16 rotateState;
/* 0x170 */ s16 rotateForTimer;
/* 0x172 */ s16 rotSpeedY;
/* 0x174 */ s16 rotSpeedX;
/* 0x178 */ f32 focusYoffset;
/* 0x17C */ ColliderCylinder collider;
}; // size = 0x1C8
enum ActorCategory
{
/* 0x00 */ ACTORCAT_SWITCH,
/* 0x01 */ ACTORCAT_BG,
/* 0x02 */ ACTORCAT_PLAYER,
/* 0x03 */ ACTORCAT_EXPLOSIVE,
/* 0x04 */ ACTORCAT_NPC,
/* 0x05 */ ACTORCAT_ENEMY,
/* 0x06 */ ACTORCAT_PROP,
/* 0x07 */ ACTORCAT_ITEMACTION,
/* 0x08 */ ACTORCAT_MISC,
/* 0x09 */ ACTORCAT_BOSS,
/* 0x0A */ ACTORCAT_DOOR,
/* 0x0B */ ACTORCAT_CHEST
/* 0x00 */ ACTORCAT_SWITCH,
/* 0x01 */ ACTORCAT_BG,
/* 0x02 */ ACTORCAT_PLAYER,
/* 0x03 */ ACTORCAT_EXPLOSIVE,
/* 0x04 */ ACTORCAT_NPC,
/* 0x05 */ ACTORCAT_ENEMY,
/* 0x06 */ ACTORCAT_PROP,
/* 0x07 */ ACTORCAT_ITEMACTION,
/* 0x08 */ ACTORCAT_MISC,
/* 0x09 */ ACTORCAT_BOSS,
/* 0x0A */ ACTORCAT_DOOR,
/* 0x0B */ ACTORCAT_CHEST
};
#define DEFINE_ACTOR(_0, enum, _2) enum,
#define DEFINE_ACTOR_INTERNAL(_0, enum, _2) enum,
#define DEFINE_ACTOR_UNSET(enum) enum,
enum ActorID {
#include "tables/actor_table.h"
/* 0x0192 */ ACTOR_ID_MAX // originally "ACTOR_DLF_MAX"
enum ActorID
{
#include "tables/actor_table.h"
/* 0x0192 */ ACTOR_ID_MAX // originally "ACTOR_DLF_MAX"
};
#undef DEFINE_ACTOR
#undef DEFINE_ACTOR_INTERNAL
#undef DEFINE_ACTOR_UNSET
enum DoorLockType {
DOORLOCK_NORMAL,
DOORLOCK_BOSS,
DOORLOCK_NORMAL_SPIRIT
enum DoorLockType
{
DOORLOCK_NORMAL,
DOORLOCK_BOSS,
DOORLOCK_NORMAL_SPIRIT
};
struct TargetContextEntry {
/* 0x00 */ Vec3f pos;
/* 0x0C */ f32 unk_0C; // radius?
/* 0x10 */ Color_RGB8 color;
struct TargetContextEntry
{
/* 0x00 */ Vec3f pos;
/* 0x0C */ f32 unk_0C; // radius?
/* 0x10 */ Color_RGB8 color;
}; // size = 0x14
struct TitleCardContext {
/* 0x00 */ void* texture;
/* 0x04 */ s16 x;
/* 0x06 */ s16 y;
/* 0x08 */ u8 width;
/* 0x09 */ u8 height;
/* 0x0A */ Timer durationTimer; // how long the title card appears for before fading
/* 0x0B */ Timer delayTimer; // how long the title card waits to appear
/* 0x0C */ s16 alpha;
/* 0x0E */ s16 intensity;
struct TitleCardContext
{
/* 0x00 */ void* texture;
/* 0x04 */ s16 x;
/* 0x06 */ s16 y;
/* 0x08 */ u8 width;
/* 0x09 */ u8 height;
/* 0x0A */ Timer durationTimer; // how long the title card appears for before fading
/* 0x0B */ Timer delayTimer; // how long the title card waits to appear
/* 0x0C */ s16 alpha;
/* 0x0E */ s16 intensity;
}; // size = 0x10
struct TargetContext {
/* 0x00 */ Vec3f naviRefPos; // possibly wrong
/* 0x0C */ Vec3f targetCenterPos;
/* 0x18 */ Color_RGBAf naviInner;
/* 0x28 */ Color_RGBAf naviOuter;
/* 0x38 */ Actor* arrowPointedActor;
/* 0x3C */ Actor* targetedActor;
/* 0x40 */ f32 unk_40;
/* 0x44 */ f32 unk_44;
/* 0x48 */ s16 unk_48;
/* 0x4A */ u8 activeCategory;
/* 0x4B */ Counter unk_4B;
/* 0x4C */ s8 unk_4C;
/* 0x4D */ char unk_4D[0x03];
/* 0x50 */ TargetContextEntry arr_50[3];
/* 0x8C */ Actor* unk_8C;
/* 0x90 */ Actor* bgmEnemy; // The nearest enemy to player with the right flags that will trigger NA_BGM_ENEMY
/* 0x94 */ Actor* unk_94;
struct TargetContext
{
/* 0x00 */ Vec3f naviRefPos; // possibly wrong
/* 0x0C */ Vec3f targetCenterPos;
/* 0x18 */ Color_RGBAf naviInner;
/* 0x28 */ Color_RGBAf naviOuter;
/* 0x38 */ Actor* arrowPointedActor;
/* 0x3C */ Actor* targetedActor;
/* 0x40 */ f32 unk_40;
/* 0x44 */ f32 unk_44;
/* 0x48 */ s16 unk_48;
/* 0x4A */ u8 activeCategory;
/* 0x4B */ Counter unk_4B;
/* 0x4C */ s8 unk_4C;
/* 0x4D */ char unk_4D[0x03];
/* 0x50 */ TargetContextEntry arr_50[3];
/* 0x8C */ Actor* unk_8C;
/* 0x90 */ Actor* bgmEnemy; // The nearest enemy to player with the right flags that will trigger NA_BGM_ENEMY
/* 0x94 */ Actor* unk_94;
}; // size = 0x98
struct ActorListEntry {
/* 0x00 */ s32 length; // number of actors loaded of this category
/* 0x04 */ Actor* head; // pointer to head of the linked list of this category (most recent actor added)
}; // size = 0x08
struct ActorListEntry
{
/* 0x00 */ s32 length; // number of actors loaded of this category
/* 0x04 */ Actor* head; // pointer to head of the linked list of this category (most recent actor added)
}; // size = 0x08
struct ActorContext
{
/* 0x0000 */ Timer freezeFlashTimer;
/* 0x0001 */ char unk_01[0x01];
/* 0x0002 */ u8 unk_02;
/* 0x0003 */ u8 unk_03;
/* 0x0004 */ char unk_04[0x04];
/* 0x0008 */ u8 total; // total number of actors loaded
/* 0x0009 */ char unk_09[0x03];
/* 0x000C */ ActorListEntry actorLists[12];
/* 0x006C */ TargetContext targetCtx;
struct {
/* 0x0104 */ u32 swch;
/* 0x0108 */ u32 tempSwch;
/* 0x010C */ u32 unk0;
/* 0x0110 */ u32 unk1;
/* 0x0114 */ u32 chest;
/* 0x0118 */ u32 clear;
/* 0x011C */ u32 tempClear;
/* 0x0120 */ u32 collect;
/* 0x0124 */ u32 tempCollect;
} flags;
/* 0x0128 */ TitleCardContext titleCtx;
/* 0x0138 */ char unk_138[0x04];
/* 0x013C */ void* absoluteSpace; // Space used to allocate actor overlays of alloc type 1
}; // size = 0x140
/* 0x0000 */ Timer freezeFlashTimer;
/* 0x0001 */ char unk_01[0x01];
/* 0x0002 */ u8 unk_02;
/* 0x0003 */ u8 unk_03;
/* 0x0004 */ char unk_04[0x04];
/* 0x0008 */ u8 total; // total number of actors loaded
/* 0x0009 */ char unk_09[0x03];
/* 0x000C */ ActorListEntry actorLists[12];
/* 0x006C */ TargetContext targetCtx;
struct
{
/* 0x0104 */ u32 swch;
/* 0x0108 */ u32 tempSwch;
/* 0x010C */ u32 unk0;
/* 0x0110 */ u32 unk1;
/* 0x0114 */ u32 chest;
/* 0x0118 */ u32 clear;
/* 0x011C */ u32 tempClear;
/* 0x0120 */ u32 collect;
/* 0x0124 */ u32 tempCollect;
} flags;
/* 0x0128 */ TitleCardContext titleCtx;
/* 0x0138 */ char unk_138[0x04];
/* 0x013C */ void* absoluteSpace; // Space used to allocate actor overlays of alloc type 1
}; // size = 0x140
struct struct_80034A14_arg1 {
/* 0x00 */ s16 unk_00;
/* 0x02 */ s16 unk_02;
/* 0x04 */ Timer unk_04;
/* 0x06 */ s16 unk_06;
/* 0x08 */ Vec3s unk_08;
/* 0x0E */ Vec3s unk_0E;
/* 0x14 */ f32 unk_14;
/* 0x18 */ Vec3f unk_18;
/* 0x24 */ s16 unk_24;
struct struct_80034A14_arg1
{
/* 0x00 */ s16 unk_00;
/* 0x02 */ s16 unk_02;
/* 0x04 */ Timer unk_04;
/* 0x06 */ s16 unk_06;
/* 0x08 */ Vec3s unk_08;
/* 0x0E */ Vec3s unk_0E;
/* 0x14 */ f32 unk_14;
/* 0x18 */ Vec3f unk_18;
/* 0x24 */ s16 unk_24;
}; // size = 0x28
// Some animation related structure
struct struct_80034EC0_Entry {
/* 0x00 */ AnimationHeader* animation;
/* 0x04 */ f32 playbackSpeed;
/* 0x08 */ f32 startFrame;
/* 0x0C */ f32 frameCount;
/* 0x10 */ u8 mode;
/* 0x14 */ f32 transitionRate;
struct struct_80034EC0_Entry
{
/* 0x00 */ AnimationHeader* animation;
/* 0x04 */ f32 playbackSpeed;
/* 0x08 */ f32 startFrame;
/* 0x0C */ f32 frameCount;
/* 0x10 */ u8 mode;
/* 0x14 */ f32 transitionRate;
}; // size = 0x18
// Another animation related structure
struct struct_D_80AA1678 {
/* 0x00 */ AnimationHeader* animation;
/* 0x04 */ f32 frameCount;
/* 0x08 */ u8 mode;
/* 0x0C */ f32 transitionRate;
struct struct_D_80AA1678
{
/* 0x00 */ AnimationHeader* animation;
/* 0x04 */ f32 frameCount;
/* 0x08 */ u8 mode;
/* 0x0C */ f32 transitionRate;
}; // size = 0x10
s32 func_800343CC(struct GlobalContext* globalCtx, Actor* actor, s16* arg2, f32 interactRange, u16(*unkFunc1)(struct GlobalContext*, Actor*), s16(*unkFunc2)(struct GlobalContext*, Actor*));
s32 func_800343CC(struct GlobalContext* globalCtx, Actor* actor, s16* arg2, f32 interactRange, u16 (*unkFunc1)(struct GlobalContext*, Actor*), s16 (*unkFunc2)(struct GlobalContext*, Actor*));
extern ActorOverlay gActorOverlayTable[ACTOR_ID_MAX]; // original name: "actor_dlftbls" 801162A0
extern s32 gMaxActorId; // original name: "MaxProfile"
extern s32 gMaxActorId; // original name: "MaxProfile"
extern Gfx D_80116280[];
#include <memory>
namespace oot::overlay
{
class IOverlay
class IOverlay
{
public:
public:
constexpr IOverlay()
{
}
{
}
virtual ~IOverlay();
virtual ~IOverlay();
};
namespace actor
@ -518,10 +541,9 @@ namespace oot::overlay
{
}
template <class T>
std::shared_ptr<IInstance> spawn()
template <class T> std::shared_ptr<IInstance> spawn()
{
return std::make_shared<T>();
return std::make_shared<T>();
}
protected:
@ -532,4 +554,4 @@ namespace oot::overlay
};
} // namespace actor
}
} // namespace oot::overlay

3
include/z64alloca.h
View File

@ -2,6 +2,5 @@
#ifndef _MSC_VER
#include <alloca.h>
#else
#define alloca _alloca
#define alloca _alloca
#endif

459
include/z64animation.h
View File

@ -14,230 +14,258 @@ struct SkelAnime;
#define ANIM_FLAG_UPDATEY (1 << 1)
#define ANIM_FLAG_NOMOVE (1 << 4)
enum AnimationModes {
/* 0 */ ANIMMODE_LOOP,
/* 1 */ ANIMMODE_LOOP_INTERP,
/* 2 */ ANIMMODE_ONCE,
/* 3 */ ANIMMODE_ONCE_INTERP,
/* 4 */ ANIMMODE_LOOP_PARTIAL,
/* 5 */ ANIMMODE_LOOP_PARTIAL_INTERP
enum AnimationModes
{
/* 0 */ ANIMMODE_LOOP,
/* 1 */ ANIMMODE_LOOP_INTERP,
/* 2 */ ANIMMODE_ONCE,
/* 3 */ ANIMMODE_ONCE_INTERP,
/* 4 */ ANIMMODE_LOOP_PARTIAL,
/* 5 */ ANIMMODE_LOOP_PARTIAL_INTERP
};
enum AnimationTapers {
/* -1 */ ANIMTAPER_DECEL = -1,
/* 0 */ ANIMTAPER_NONE,
/* 1 */ ANIMTAPER_ACCEL
enum AnimationTapers
{
/* -1 */ ANIMTAPER_DECEL = -1,
/* 0 */ ANIMTAPER_NONE,
/* 1 */ ANIMTAPER_ACCEL
};
struct StandardLimb {
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ Gfx* dList;
struct StandardLimb
{
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ Gfx* dList;
}; // size = 0xC
struct LodLimb {
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ Gfx* dLists[2]; // Near and far
}; // size = 0x10
struct LodLimb
{
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ Gfx* dLists[2]; // Near and far
}; // size = 0x10
struct SkinLimb {
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ s32 unk_8; // Type of data contained in segment
/* 0x0C */ void* segment; // Segment address of data. Currently unclear what.
}; // size = 0x10
struct SkinLimb
{
/* 0x00 */ Vec3s jointPos; // Root is position in model space, children are relative to parent
/* 0x06 */ u8 child;
/* 0x07 */ u8 sibling;
/* 0x08 */ s32 unk_8; // Type of data contained in segment
/* 0x0C */ void* segment; // Segment address of data. Currently unclear what.
}; // size = 0x10
struct LegacyLimb {
/* 0x000 */ Gfx* dList;
/* 0x004 */ Vec3f trans;
/* 0x010 */ Vec3s rot;
/* 0x018 */ struct LegacyLimb* sibling;
/* 0x01C */ struct LegacyLimb* child;
struct LegacyLimb
{
/* 0x000 */ Gfx* dList;
/* 0x004 */ Vec3f trans;
/* 0x010 */ Vec3s rot;
/* 0x018 */ struct LegacyLimb* sibling;
/* 0x01C */ struct LegacyLimb* child;
}; // size = 0x20
// Model has limbs with only rigid meshes
struct SkeletonHeader {
/* 0x00 */ void** segment;
/* 0x04 */ u8 limbCount;
struct SkeletonHeader
{
/* 0x00 */ void** segment;
/* 0x04 */ u8 limbCount;
}; // size = 0x8
// Model has limbs with flexible meshes
struct FlexSkeletonHeader {
/* 0x00 */ SkeletonHeader sh;
/* 0x08 */ u8 dListCount;
struct FlexSkeletonHeader
{
/* 0x00 */ SkeletonHeader sh;
/* 0x08 */ u8 dListCount;
}; // size = 0xC
// Index into the frame data table.
struct JointIndex {
/* 0x00 */ u16 x;
/* 0x02 */ u16 y;
/* 0x04 */ u16 z;
// Index into the frame data table.
struct JointIndex
{
/* 0x00 */ u16 x;
/* 0x02 */ u16 y;
/* 0x04 */ u16 z;
}; // size = 0x06
struct AnimationHeaderCommon {
/* 0x00 */ s16 frameCount;
struct AnimationHeaderCommon
{
/* 0x00 */ s16 frameCount;
};
struct LinkAnimationHeader {
/* 0x00 */ AnimationHeaderCommon common;
/* 0x04 */ void* segment;
struct LinkAnimationHeader
{
/* 0x00 */ AnimationHeaderCommon common;
/* 0x04 */ void* segment;
}; // size = 0x8
struct AnimationHeader {
/* 0x00 */ AnimationHeaderCommon common;
/* 0x04 */ s16* frameData; // "tbl"
/* 0x08 */ JointIndex* jointIndices; // "ref_tbl"
/* 0x0C */ u16 staticIndexMax;
struct AnimationHeader
{
/* 0x00 */ AnimationHeaderCommon common;
/* 0x04 */ s16* frameData; // "tbl"
/* 0x08 */ JointIndex* jointIndices; // "ref_tbl"
/* 0x0C */ u16 staticIndexMax;
}; // size = 0x10
// Unused
struct JointKey {
/* 0x00 */ s16 xMax;
/* 0x02 */ s16 x;
/* 0x04 */ s16 yMax;
/* 0x06 */ s16 y;
/* 0x08 */ s16 zMax;
/* 0x0A */ s16 z;
struct JointKey
{
/* 0x00 */ s16 xMax;
/* 0x02 */ s16 x;
/* 0x04 */ s16 yMax;
/* 0x06 */ s16 y;
/* 0x08 */ s16 zMax;
/* 0x0A */ s16 z;
}; // size = 0x0C
// Unused
struct LegacyAnimationHeader {
/* 0x00 */ s16 frameCount;
/* 0x02 */ s16 limbCount;
/* 0x04 */ s16* frameData;
/* 0x08 */ JointKey* jointKey;
struct LegacyAnimationHeader
{
/* 0x00 */ s16 frameCount;
/* 0x02 */ s16 limbCount;
/* 0x04 */ s16* frameData;
/* 0x08 */ JointKey* jointKey;
}; // size = 0xC
typedef s32 (*OverrideLimbDrawOpa)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
void*);
typedef s32 (*OverrideLimbDrawOpa)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, void*);
typedef void (*PostLimbDrawOpa)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, void*);
typedef s32 (*OverrideLimbDraw)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
void*, Gfx** gfx);
typedef s32 (*OverrideLimbDraw)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, void*, Gfx** gfx);
typedef void (*PostLimbDraw)(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, void*, Gfx** gfx);
enum AnimationType {
ANIMENTRY_LOADFRAME,
ANIMENTRY_COPYALL,
ANIMENTRY_INTERP,
ANIMENTRY_COPYTRUE,
ANIMENTRY_COPYFALSE,
ANIMENTRY_MOVEACTOR
enum AnimationType
{
ANIMENTRY_LOADFRAME,
ANIMENTRY_COPYALL,
ANIMENTRY_INTERP,
ANIMENTRY_COPYTRUE,
ANIMENTRY_COPYFALSE,
ANIMENTRY_MOVEACTOR
};
struct AnimEntryLoadFrame {
/* 0x000 */ DmaRequest req;
/* 0x020 */ OSMesgQueue msgQueue;
/* 0x038 */ OSMesg msg;
struct AnimEntryLoadFrame
{
/* 0x000 */ DmaRequest req;
/* 0x020 */ OSMesgQueue msgQueue;
/* 0x038 */ OSMesg msg;
}; // size = 0x3C
struct AnimEntryCopyAll {
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
struct AnimEntryCopyAll
{
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
}; // size = 0xC
struct AnimEntryInterp {
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* base;
/* 0x008 */ Vec3s* mod;
/* 0x00C */ f32 weight;
struct AnimEntryInterp
{
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* base;
/* 0x008 */ Vec3s* mod;
/* 0x00C */ f32 weight;
}; // size = 0x10
struct AnimEntryCopyTrue {
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
/* 0x00C */ const u8* copyFlag;
struct AnimEntryCopyTrue
{
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
/* 0x00C */ const u8* copyFlag;
}; // size = 0x10
struct AnimEntryCopyFalse {
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
/* 0x00C */ const u8* copyFlag;
struct AnimEntryCopyFalse
{
/* 0x000 */ u8 queueFlag;
/* 0x001 */ u8 vecCount;
/* 0x004 */ Vec3s* dst;
/* 0x008 */ Vec3s* src;
/* 0x00C */ const u8* copyFlag;
}; // size = 0x10
struct AnimEntryMoveActor {
/* 0x000 */ struct Actor* actor;
/* 0x004 */ struct SkelAnime* skelAnime;
/* 0x008 */ f32 unk_08;
struct AnimEntryMoveActor
{
/* 0x000 */ struct Actor* actor;
/* 0x004 */ struct SkelAnime* skelAnime;
/* 0x008 */ f32 unk_08;
}; // size = 0xC
union AnimationEntryData {
AnimEntryLoadFrame load;
AnimEntryCopyAll copy;
AnimEntryInterp interp;
AnimEntryCopyTrue copy1;
AnimEntryCopyFalse copy0;
AnimEntryMoveActor move;
union AnimationEntryData
{
AnimEntryLoadFrame load;
AnimEntryCopyAll copy;
AnimEntryInterp interp;
AnimEntryCopyTrue copy1;
AnimEntryCopyFalse copy0;
AnimEntryMoveActor move;
}; // size = 0x3C
struct AnimationEntry {
/* 0x00 */ u8 type;
/* 0x04 */ AnimationEntryData data;
struct AnimationEntry
{
/* 0x00 */ u8 type;
/* 0x04 */ AnimationEntryData data;
}; // size = 0x40
struct AnimationContext {
s16 animationCount;
AnimationEntry entries[ANIMATION_ENTRY_MAX];
struct AnimationContext
{
s16 animationCount;
AnimationEntry entries[ANIMATION_ENTRY_MAX];
}; // size = 0xC84
typedef void (*AnimationEntryCallback)(struct GlobalContext* globalCtx, AnimationEntryData* data);
// fcurve_skelanime structs
struct TransformData {
/* 0x0000 */ u16 unk_00; // appears to be flags
/* 0x0002 */ s16 unk_02;
/* 0x0004 */ s16 unk_04;
/* 0x0006 */ s16 unk_06;
/* 0x0008 */ f32 unk_08;
struct TransformData
{
/* 0x0000 */ u16 unk_00; // appears to be flags
/* 0x0002 */ s16 unk_02;
/* 0x0004 */ s16 unk_04;
/* 0x0006 */ s16 unk_06;
/* 0x0008 */ f32 unk_08;
}; // size = 0xC
struct TransformUpdateIndex {
/* 0x0000 */ u8* refIndex;
/* 0x0004 */ TransformData* transformData;
/* 0x0008 */ s16* copyValues;
/* 0x000C */ s16 unk_0C;
/* 0x000E */ s16 unk_0E;
struct TransformUpdateIndex
{
/* 0x0000 */ u8* refIndex;
/* 0x0004 */ TransformData* transformData;
/* 0x0008 */ s16* copyValues;
/* 0x000C */ s16 unk_0C;
/* 0x000E */ s16 unk_0E;
}; // size = 0x10
struct SkelCurveLimb {
/* 0x0000 */ u8 firstChildIdx;
/* 0x0001 */ u8 nextLimbIdx;
/* 0x0004 */ Gfx* dList[2];
struct SkelCurveLimb
{
/* 0x0000 */ u8 firstChildIdx;
/* 0x0001 */ u8 nextLimbIdx;
/* 0x0004 */ Gfx* dList[2];
}; // size = 0xC
struct SkelCurveLimbList {
/* 0x0000 */ SkelCurveLimb** limbs;
/* 0x0004 */ u8 limbCount;
struct SkelCurveLimbList
{
/* 0x0000 */ SkelCurveLimb** limbs;
/* 0x0004 */ u8 limbCount;
}; // size = 0x8
struct LimbTransform {
/* 0x0000 */ Vec3s scale;
/* 0x0006 */ Vec3s rot;
/* 0x000C */ Vec3s pos;
struct LimbTransform
{
/* 0x0000 */ Vec3s scale;
/* 0x0006 */ Vec3s rot;
/* 0x000C */ Vec3s pos;
}; // size = 0x12
struct SkelAnimeCurve {
/* 0x0000 */ u8 limbCount;
/* 0x0004 */ SkelCurveLimb** limbList;
/* 0x0008 */ TransformUpdateIndex* transUpdIdx;
/* 0x000C */ f32 unk_0C; // seems to be unused
/* 0x0010 */ f32 animFinalFrame;
/* 0x0014 */ f32 animSpeed;
/* 0x0018 */ f32 animCurFrame;
/* 0x001C */ LimbTransform* transforms;
struct SkelAnimeCurve
{
/* 0x0000 */ u8 limbCount;
/* 0x0004 */ SkelCurveLimb** limbList;
/* 0x0008 */ TransformUpdateIndex* transUpdIdx;
/* 0x000C */ f32 unk_0C; // seems to be unused
/* 0x0010 */ f32 animFinalFrame;
/* 0x0014 */ f32 animSpeed;
/* 0x0018 */ f32 animCurFrame;
/* 0x001C */ LimbTransform* transforms;
}; // size = 0x20
typedef s32 (*OverrideCurveLimbDraw)(struct GlobalContext* globalCtx, SkelAnimeCurve* skelCurve, s32 limbIndex, void*);
@ -245,74 +273,81 @@ typedef void (*PostCurveLimbDraw)(struct GlobalContext* globalCtx, SkelAnimeCurv
typedef s32 (*AnimUpdateFunc)();
struct SkelAnime {
/* 0x00 */ u8 limbCount; // Number of limbs in the skeleton
/* 0x01 */ u8 mode; // 0: loop, 2: play once, 4: partial loop. +1 to interpolate between frames.
/* 0x02 */ u8 dListCount; // Number of display lists in a flexible skeleton
/* 0x03 */ s8 taper; // Tapering to use when morphing between animations. Only used by Door_Warp1.
/* 0x04 */ void** skeleton; // An array of pointers to limbs. Can be StandardLimb, LodLimb, or SkinLimb.
/* 0x08 */ void* animation; // Can be an AnimationHeader or LinkAnimationHeader.
/* 0x0C */ f32 startFrame; // In mode 4, start of partial loop.
/* 0x10 */ f32 endFrame; // In mode 2, Update returns true when curFrame is equal to this. In mode 4, end of partial loop.
/* 0x14 */ f32 animLength; // Total number of frames in the current animation's file.
/* 0x18 */ f32 curFrame; // Current frame in the animation
/* 0x1C */ f32 playSpeed; // Multiplied by R_UPDATE_RATE / 3 to get the animation's frame rate.
/* 0x20 */ Vec3s* jointTable; // Current translation of model and rotations of all limbs
/* 0x24 */ Vec3s* morphTable; // Table of values used to morph between animations
/* 0x28 */ f32 morphWeight; // Weight of the current animation morph as a fraction in [0,1]
/* 0x2C */ f32 morphRate; // Reciprocal of the number of frames in the morph
/* 0x30 */ s32 (*update)(GlobalContext*, SkelAnime*); // Can be Loop, Partial loop, Play once, Morph, or Tapered morph. Link only has Loop, Play once, and Morph
/* 0x34 */ s8 initFlags; // Flags used when initializing Link's skeleton
/* 0x35 */ u8 moveFlags; // Flags used for animations that move the actor in worldspace.
/* 0x36 */ s16 prevRot; // Previous rotation in worldspace.
/* 0x38 */ Vec3s prevTransl; // Previous modelspace translation.
/* 0x3E */ Vec3s baseTransl; // Base modelspace translation.
}; // size = 0x44
struct SkelAnime
{
/* 0x00 */ u8 limbCount; // Number of limbs in the skeleton
/* 0x01 */ u8 mode; // 0: loop, 2: play once, 4: partial loop. +1 to interpolate between frames.
/* 0x02 */ u8 dListCount; // Number of display lists in a flexible skeleton
/* 0x03 */ s8 taper; // Tapering to use when morphing between animations. Only used by Door_Warp1.
/* 0x04 */ void** skeleton; // An array of pointers to limbs. Can be StandardLimb, LodLimb, or SkinLimb.
/* 0x08 */ void* animation; // Can be an AnimationHeader or LinkAnimationHeader.
/* 0x0C */ f32 startFrame; // In mode 4, start of partial loop.
/* 0x10 */ f32 endFrame; // In mode 2, Update returns true when curFrame is equal to this. In mode 4, end of partial loop.
/* 0x14 */ f32 animLength; // Total number of frames in the current animation's file.
/* 0x18 */ f32 curFrame; // Current frame in the animation
/* 0x1C */ f32 playSpeed; // Multiplied by R_UPDATE_RATE / 3 to get the animation's frame rate.
/* 0x20 */ Vec3s* jointTable; // Current translation of model and rotations of all limbs
/* 0x24 */ Vec3s* morphTable; // Table of values used to morph between animations
/* 0x28 */ f32 morphWeight; // Weight of the current animation morph as a fraction in [0,1]
/* 0x2C */ f32 morphRate; // Reciprocal of the number of frames in the morph
/* 0x30 */ s32 (*update)(GlobalContext*, SkelAnime*); // Can be Loop, Partial loop, Play once, Morph, or Tapered morph. Link only has Loop, Play once, and Morph
/* 0x34 */ s8 initFlags; // Flags used when initializing Link's skeleton
/* 0x35 */ u8 moveFlags; // Flags used for animations that move the actor in worldspace.
/* 0x36 */ s16 prevRot; // Previous rotation in worldspace.
/* 0x38 */ Vec3s prevTransl; // Previous modelspace translation.
/* 0x3E */ Vec3s baseTransl; // Base modelspace translation.
}; // size = 0x44
struct Struct_800A57C0 {
/* 0x000 */ u16 unk_0;
/* 0x002 */ s16 unk_2;
/* 0x004 */ s16 unk_4;
/* 0x006 */ s8 unk_6;
/* 0x007 */ s8 unk_7;
/* 0x008 */ s8 unk_8;
/* 0x009 */ u8 unk_9;
struct Struct_800A57C0
{
/* 0x000 */ u16 unk_0;
/* 0x002 */ s16 unk_2;
/* 0x004 */ s16 unk_4;
/* 0x006 */ s8 unk_6;
/* 0x007 */ s8 unk_7;
/* 0x008 */ s8 unk_8;
/* 0x009 */ u8 unk_9;
}; // size = 0xA
struct Struct_800A598C_2 {
/* 0x000 */ u8 unk_0;
/* 0x002 */ s16 x;
/* 0x004 */ s16 y;
/* 0x006 */ s16 z;
/* 0x008 */ u8 unk_8;
struct Struct_800A598C_2
{
/* 0x000 */ u8 unk_0;
/* 0x002 */ s16 x;
/* 0x004 */ s16 y;
/* 0x006 */ s16 z;
/* 0x008 */ u8 unk_8;
}; // size = 0xA
struct Struct_800A598C {
/* 0x000 */ u16 unk_0;
/* 0x002 */ u16 unk_2;
/* 0x004 */ u16 unk_4;
/* 0x008 */ Struct_800A57C0* unk_8;
/* 0x00C */ Struct_800A598C_2* unk_C;
struct Struct_800A598C
{
/* 0x000 */ u16 unk_0;
/* 0x002 */ u16 unk_2;
/* 0x004 */ u16 unk_4;
/* 0x008 */ Struct_800A57C0* unk_8;
/* 0x00C */ Struct_800A598C_2* unk_C;
}; // size = 0x10
struct Struct_800A5E28 {
/* 0x000 */ u16 unk_0;
/* 0x002 */ u16 unk_2;
/* 0x004 */ Struct_800A598C* unk_4;
/* 0x008 */ Gfx* unk_8;
struct Struct_800A5E28
{
/* 0x000 */ u16 unk_0;
/* 0x002 */ u16 unk_2;
/* 0x004 */ Struct_800A598C* unk_4;
/* 0x008 */ Gfx* unk_8;
}; // size = 0xC
struct SkinAvb {
/* 0x000 */ u8 unk_0;
/* 0x004 */ Vtx* buf[2];
struct SkinAvb
{
/* 0x000 */ u8 unk_0;
/* 0x004 */ Vtx* buf[2];
}; // size = 0xC
struct PSkinAwb {
/* 0x000 */ SkeletonHeader* skeletonHeader;
/* 0x004 */ MtxF mtx;
/* 0x044 */ s32 avbCount;
/* 0x048 */ SkinAvb* avbTbl;
/* 0x04C */ SkelAnime skelAnime;
struct PSkinAwb
{
/* 0x000 */ SkeletonHeader* skeletonHeader;
/* 0x004 */ MtxF mtx;
/* 0x044 */ s32 avbCount;
/* 0x048 */ SkinAvb* avbTbl;
/* 0x04C */ SkelAnime skelAnime;
}; // size = 0x90
typedef void (*SkinCallback)(struct Actor*, struct GlobalContext*, PSkinAwb*);

2007
include/z64audio.h
View File

File diff suppressed because it is too large Load Diff

349
include/z64bgcheck.h
View File

@ -6,7 +6,7 @@ struct Actor;
struct DynaPolyActor;
#define COLPOLY_NORMAL_FRAC (1.0f / SHT_MAX)
#define COLPOLY_SNORMAL(x) ((s16)((x) * SHT_MAX))
#define COLPOLY_SNORMAL(x) ((s16)((x)*SHT_MAX))
#define COLPOLY_GET_NORMAL(n) ((n)*COLPOLY_NORMAL_FRAC)
#define COLPOLY_VIA_FLAG_TEST(vIA, flags) ((vIA) & (((flags)&7) << 13))
#define COLPOLY_VTX_INDEX(vI) ((vI)&0x1FFF)
@ -28,170 +28,188 @@ struct DynaPolyActor;
#define WATERBOX_ROOM(p) ((p >> 13) & 0x3F)
struct ScaleRotPos {
Vec3f scale;
Vec3s rot;
Vec3f pos;
struct ScaleRotPos
{
Vec3f scale;
Vec3s rot;
Vec3f pos;
};
struct CollisionPoly
{
/* 0x00 */ u16 type;
union {
u16 vtxData[3];
struct {
/* 0x02 */ u16 flags_vIA; // 0xE000 is poly exclusion flags (xpFlags), 0x1FFF is vtxId
/* 0x04 */ u16 flags_vIB; // 0xE000 is flags, 0x1FFF is vtxId
// 0x2000 = poly IsConveyor surface
/* 0x06 */ u16 vIC;
};
};
/* 0x08 */ Vec3s normal; // Unit normal vector
// Value ranges from -0x7FFF to 0x7FFF, representing -1.0 to 1.0; 0x8000 is invalid
/* 0x00 */ u16 type;
union
{
u16 vtxData[3];
struct
{
/* 0x02 */ u16 flags_vIA; // 0xE000 is poly exclusion flags (xpFlags), 0x1FFF is vtxId
/* 0x04 */ u16 flags_vIB; // 0xE000 is flags, 0x1FFF is vtxId
// 0x2000 = poly IsConveyor surface
/* 0x06 */ u16 vIC;
};
};
/* 0x08 */ Vec3s normal; // Unit normal vector
// Value ranges from -0x7FFF to 0x7FFF, representing -1.0 to 1.0; 0x8000 is invalid
/* 0x0E */ s16 dist; // Plane distance from origin along the normal
}; // size = 0x10
/* 0x0E */ s16 dist; // Plane distance from origin along the normal
}; // size = 0x10
struct CamData {
/* 0x00 */ u16 cameraSType;
/* 0x02 */ s16 numCameras;
/* 0x04 */ Vec3s* camPosData;
struct CamData
{
/* 0x00 */ u16 cameraSType;
/* 0x02 */ s16 numCameras;
/* 0x04 */ Vec3s* camPosData;
};
struct WaterBox {
/* 0x00 */ s16 xMin;
/* 0x02 */ s16 ySurface;
/* 0x04 */ s16 zMin;
/* 0x06 */ s16 xLength;
/* 0x08 */ s16 zLength;
/* 0x0C */ u32 properties;
struct WaterBox
{
/* 0x00 */ s16 xMin;
/* 0x02 */ s16 ySurface;
/* 0x04 */ s16 zMin;
/* 0x06 */ s16 xLength;
/* 0x08 */ s16 zLength;
/* 0x0C */ u32 properties;
// 0x0008_0000 = ?
// 0x0007_E000 = Room Index, 0x3F = all rooms
// 0x0000_1F00 = Lighting Settings Index
// 0x0000_00FF = CamData index
// 0x0008_0000 = ?
// 0x0007_E000 = Room Index, 0x3F = all rooms
// 0x0000_1F00 = Lighting Settings Index
// 0x0000_00FF = CamData index
}; // size = 0x10
struct SurfaceType {
u32 data[2];
struct SurfaceType
{
u32 data[2];
// Type 1
// 0x0800_0000 = wall damage
// Type 1
// 0x0800_0000 = wall damage
};
struct CollisionHeader {
/* 0x00 */ Vec3s minBounds; // minimum coordinates of poly bounding box
/* 0x06 */ Vec3s maxBounds; // maximum coordinates of poly bounding box
/* 0x0C */ u16 numVertices;
/* 0x10 */ Vec3s* vtxList;
/* 0x14 */ u16 numPolygons;
/* 0x18 */ CollisionPoly* polyList;
/* 0x1C */ SurfaceType* surfaceTypeList;
/* 0x20 */ CamData* cameraDataList;
/* 0x24 */ u16 numWaterBoxes;
/* 0x28 */ WaterBox* waterBoxes;
struct CollisionHeader
{
/* 0x00 */ Vec3s minBounds; // minimum coordinates of poly bounding box
/* 0x06 */ Vec3s maxBounds; // maximum coordinates of poly bounding box
/* 0x0C */ u16 numVertices;
/* 0x10 */ Vec3s* vtxList;
/* 0x14 */ u16 numPolygons;
/* 0x18 */ CollisionPoly* polyList;
/* 0x1C */ SurfaceType* surfaceTypeList;
/* 0x20 */ CamData* cameraDataList;
/* 0x24 */ u16 numWaterBoxes;
/* 0x28 */ WaterBox* waterBoxes;
}; // original name: BGDataInfo
struct SSNode {
s16 polyId;
u16 next; // next SSNode index
struct SSNode
{
s16 polyId;
u16 next; // next SSNode index
};
struct SSList {
u16 head; // first SSNode index
struct SSList
{
u16 head; // first SSNode index
};
struct SSNodeList {
/* 0x00 */ u16 max; // original name: short_slist_node_size
/* 0x02 */ u16 count; // original name: short_slist_node_last_index
/* 0x04 */ SSNode* tbl; // original name: short_slist_node_tbl
/* 0x08 */ u8* polyCheckTbl; // points to an array of bytes, one per static poly. Zero initialized when starting a
// bg check, and set to 1 if that poly has already been tested.
struct SSNodeList
{
/* 0x00 */ u16 max; // original name: short_slist_node_size
/* 0x02 */ u16 count; // original name: short_slist_node_last_index
/* 0x04 */ SSNode* tbl; // original name: short_slist_node_tbl
/* 0x08 */ u8* polyCheckTbl; // points to an array of bytes, one per static poly. Zero initialized when starting a
// bg check, and set to 1 if that poly has already been tested.
};
struct DynaSSNodeList {
SSNode* tbl;
s32 count;
s32 max;
struct DynaSSNodeList
{
SSNode* tbl;
s32 count;
s32 max;
};
struct StaticLookup {
SSList floor;
SSList wall;
SSList ceiling;
struct StaticLookup
{
SSList floor;
SSList wall;
SSList ceiling;
};
struct DynaLookup {
u16 polyStartIndex;
SSList ceiling;
SSList wall;
SSList floor;
struct DynaLookup
{
u16 polyStartIndex;
SSList ceiling;
SSList wall;
SSList floor;
};
struct BgActor {
/* 0x00 */ struct Actor* actor;
/* 0x04 */ CollisionHeader* colHeader;
/* 0x08 */ DynaLookup dynaLookup;
/* 0x10 */ u16 vtxStartIndex;
/* 0x14 */ ScaleRotPos prevTransform;
/* 0x34 */ ScaleRotPos curTransform;
/* 0x54 */ Sphere16 boundingSphere;
/* 0x5C */ f32 minY;
/* 0x60 */ f32 maxY;
struct BgActor
{
/* 0x00 */ struct Actor* actor;
/* 0x04 */ CollisionHeader* colHeader;
/* 0x08 */ DynaLookup dynaLookup;
/* 0x10 */ u16 vtxStartIndex;
/* 0x14 */ ScaleRotPos prevTransform;
/* 0x34 */ ScaleRotPos curTransform;
/* 0x54 */ Sphere16 boundingSphere;
/* 0x5C */ f32 minY;
/* 0x60 */ f32 maxY;
}; // size = 0x64
struct DynaCollisionContext {
/* 0x0000 */ u8 bitFlag;
/* 0x0004 */ BgActor bgActors[BG_ACTOR_MAX];
/* 0x138C */ u16 bgActorFlags[BG_ACTOR_MAX]; // & 0x0008 = no dyna ceiling
/* 0x13F0 */ CollisionPoly* polyList;
/* 0x13F4 */ Vec3s* vtxList;
/* 0x13F8 */ DynaSSNodeList polyNodes;
/* 0x1404 */ s32 polyNodesMax;
/* 0x1408 */ s32 polyListMax;
/* 0x140C */ s32 vtxListMax;
struct DynaCollisionContext
{
/* 0x0000 */ u8 bitFlag;
/* 0x0004 */ BgActor bgActors[BG_ACTOR_MAX];
/* 0x138C */ u16 bgActorFlags[BG_ACTOR_MAX]; // & 0x0008 = no dyna ceiling
/* 0x13F0 */ CollisionPoly* polyList;
/* 0x13F4 */ Vec3s* vtxList;
/* 0x13F8 */ DynaSSNodeList polyNodes;
/* 0x1404 */ s32 polyNodesMax;
/* 0x1408 */ s32 polyListMax;
/* 0x140C */ s32 vtxListMax;
}; // size = 0x1410
struct CollisionContext {
/* 0x00 */ CollisionHeader* colHeader; // scene's static collision
/* 0x04 */ Vec3f minBounds; // minimum coordinates of collision bounding box
/* 0x10 */ Vec3f maxBounds; // maximum coordinates of collision bounding box
/* 0x1C */ Vec3i subdivAmount; // x, y, z subdivisions of the scene's static collision
/* 0x28 */ Vec3f subdivLength; // x, y, z subdivision worldspace lengths
/* 0x34 */ Vec3f subdivLengthInv; // inverse of subdivision length
/* 0x40 */ StaticLookup* lookupTbl; // 3d array of length subdivAmount
/* 0x44 */ SSNodeList polyNodes;
/* 0x50 */ DynaCollisionContext dyna;
/* 0x1460 */ u32 memSize; // Size of all allocated memory plus CollisionContext
}; // size = 0x1464
struct CollisionContext
{
/* 0x00 */ CollisionHeader* colHeader; // scene's static collision
/* 0x04 */ Vec3f minBounds; // minimum coordinates of collision bounding box
/* 0x10 */ Vec3f maxBounds; // maximum coordinates of collision bounding box
/* 0x1C */ Vec3i subdivAmount; // x, y, z subdivisions of the scene's static collision
/* 0x28 */ Vec3f subdivLength; // x, y, z subdivision worldspace lengths
/* 0x34 */ Vec3f subdivLengthInv; // inverse of subdivision length
/* 0x40 */ StaticLookup* lookupTbl; // 3d array of length subdivAmount
/* 0x44 */ SSNodeList polyNodes;
/* 0x50 */ DynaCollisionContext dyna;
/* 0x1460 */ u32 memSize; // Size of all allocated memory plus CollisionContext
}; // size = 0x1464
struct DynaRaycast {
/* 0x00 */ struct GlobalContext* globalCtx;
/* 0x04 */ struct CollisionContext* colCtx;
/* 0x08 */ u16 xpFlags;
/* 0x0C */ CollisionPoly** resultPoly;
/* 0x10 */ f32 yIntersect;
/* 0x14 */ Vec3f* pos;
/* 0x18 */ s32* bgId;
/* 0x1C */ struct Actor* actor;
/* 0x20 */ u32 unk_20;
/* 0x24 */ f32 chkDist;
/* 0x28 */ DynaCollisionContext* dyna;
/* 0x2C */ SSList* ssList;
struct DynaRaycast
{
/* 0x00 */ struct GlobalContext* globalCtx;
/* 0x04 */ struct CollisionContext* colCtx;
/* 0x08 */ u16 xpFlags;
/* 0x0C */ CollisionPoly** resultPoly;
/* 0x10 */ f32 yIntersect;
/* 0x14 */ Vec3f* pos;
/* 0x18 */ s32* bgId;
/* 0x1C */ struct Actor* actor;
/* 0x20 */ u32 unk_20;
/* 0x24 */ f32 chkDist;
/* 0x28 */ DynaCollisionContext* dyna;
/* 0x2C */ SSList* ssList;
};
struct DynaLineTest {
/* 0x00 */ struct CollisionContext* colCtx;
/* 0x04 */ u16 xpFlags;
/* 0x08 */ DynaCollisionContext* dyna;
/* 0x0C */ SSList* ssList;
/* 0x10 */ Vec3f* posA;
/* 0x14 */ Vec3f* posB;
/* 0x18 */ Vec3f* posResult;
/* 0x1C */ CollisionPoly** resultPoly;
/* 0x20 */ s32 chkOneFace; // bccFlags & 0x8
/* 0x24 */ f32* distSq; // distance from posA to poly squared
/* 0x28 */ f32 chkDist; // distance from poly
struct DynaLineTest
{
/* 0x00 */ struct CollisionContext* colCtx;
/* 0x04 */ u16 xpFlags;
/* 0x08 */ DynaCollisionContext* dyna;
/* 0x0C */ SSList* ssList;
/* 0x10 */ Vec3f* posA;
/* 0x14 */ Vec3f* posB;
/* 0x18 */ Vec3f* posResult;
/* 0x1C */ CollisionPoly** resultPoly;
/* 0x20 */ s32 chkOneFace; // bccFlags & 0x8
/* 0x24 */ f32* distSq; // distance from posA to poly squared
/* 0x28 */ f32 chkDist; // distance from poly
};
/*
@ -202,23 +220,23 @@ void func_80038A28(CollisionPoly* poly, f32 tx, f32 ty, f32 tz, MtxF* dest);
f32 CollisionPoly_GetPointDistanceFromPlane(CollisionPoly* poly, Vec3f* point);
void CollisionPoly_GetVerticesByBgId(CollisionPoly* poly, s32 bgId, CollisionContext* colCtx, Vec3f* dest);
s32 BgCheck_CheckStaticCeiling(StaticLookup* lookup, u16 xpFlags, CollisionContext* colCtx, f32* outY, Vec3f* pos,
f32 checkHeight, CollisionPoly** outPoly);
f32 checkHeight, CollisionPoly** outPoly);
s32 BgCheck_CheckLineAgainstSSList(SSList* headNodeId, CollisionContext* colCtx, u16 xpFlags1, u16 xpFlags2,
Vec3f* posA, Vec3f* posB, Vec3f* outPos, CollisionPoly** outPoly, f32* outDistSq,
f32 chkDist, s32 bccFlags);
Vec3f* posA, Vec3f* posB, Vec3f* outPos, CollisionPoly** outPoly, f32* outDistSq,
f32 chkDist, s32 bccFlags);
void BgCheck_GetStaticLookupIndicesFromPos(CollisionContext* colCtx, Vec3f* pos, Vec3i* arg2);
void BgCheck_Allocate(CollisionContext* colCtx, struct GlobalContext* globalCtx, CollisionHeader* colHeader);
s32 BgCheck_PosInStaticBoundingBox(CollisionContext* colCtx, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor2(struct GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly,
Vec3f* pos);
Vec3f* pos);
f32 BgCheck_EntityRaycastFloor3(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor4(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, struct Actor* actor,
Vec3f* arg4);
Vec3f* arg4);
f32 BgCheck_EntityRaycastFloor5(struct GlobalContext* globalCtx, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId,
struct Actor* actor, Vec3f* pos);
struct Actor* actor, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor6(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, struct Actor* actor, Vec3f* pos,
f32 chkDist);
f32 chkDist);
f32 BgCheck_EntityRaycastFloor7(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, struct Actor* actor, Vec3f* pos);
f32 BgCheck_AnyRaycastFloor1(CollisionContext* colCtx, CollisionPoly* outPoly, Vec3f* pos);
f32 BgCheck_AnyRaycastFloor2(CollisionContext* colCtx, CollisionPoly* outPoly, s32* bgId, Vec3f* pos);
@ -226,42 +244,42 @@ f32 BgCheck_CameraRaycastFloor2(CollisionContext* colCtx, CollisionPoly** outPol
f32 BgCheck_EntityRaycastFloor8(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, struct Actor* actor, Vec3f* pos);
f32 BgCheck_EntityRaycastFloor9(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
s32 BgCheck_CheckWallImpl(CollisionContext* colCtx, u16 xpFlags, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev,
f32 radius, CollisionPoly** outPoly, s32* outBgId, struct Actor* actor, f32 checkHeight, u8 argA);
f32 radius, CollisionPoly** outPoly, s32* outBgId, struct Actor* actor, f32 checkHeight, u8 argA);
s32 BgCheck_EntitySphVsWall1(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius,
CollisionPoly** outPoly, f32 checkHeight);
CollisionPoly** outPoly, f32 checkHeight);
s32 BgCheck_EntitySphVsWall2(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius,
CollisionPoly** outPoly, s32* outBgId, f32 checkHeight);
CollisionPoly** outPoly, s32* outBgId, f32 checkHeight);
s32 BgCheck_EntitySphVsWall3(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius,
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor, f32 checkHeight);
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor, f32 checkHeight);
s32 BgCheck_EntitySphVsWall4(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius,
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor, f32 checkHeight);
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor, f32 checkHeight);
s32 BgCheck_AnyCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight);
s32 BgCheck_EntityCheckCeiling(CollisionContext* colCtx, f32* arg1, Vec3f* arg2, f32 arg3, CollisionPoly** outPoly,
s32* outBgId, struct Actor* actor);
s32* outBgId, struct Actor* actor);
s32 BgCheck_CheckLineImpl(CollisionContext* colCtx, u16 xpFlags1, u16 xpFlags2, Vec3f* posA, Vec3f* posB,
Vec3f* posResult, CollisionPoly** outPoly, s32* bgId, struct Actor* actor, f32 chkDist,
u32 bccFlags);
Vec3f* posResult, CollisionPoly** outPoly, s32* bgId, struct Actor* actor, f32 chkDist,
u32 bccFlags);
s32 BgCheck_CameraLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_CameraLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_EntityLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_EntityLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId,
struct Actor* actor);
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId,
struct Actor* actor);
s32 BgCheck_EntityLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId,
struct Actor* actor, f32 chkDist);
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId,
struct Actor* actor, f32 chkDist);
s32 BgCheck_ProjectileLineTest(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace,
s32* bgId);
CollisionPoly** outPoly, s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace,
s32* bgId);
s32 BgCheck_AnyLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly,
s32 chkOneFace);
s32 chkOneFace);
s32 BgCheck_AnyLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly,
s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace);
s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace);
s32 BgCheck_AnyLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly,
s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 chkWall, s32 chkFloor, s32 chkCeil, s32 chkOneFace, s32* bgId);
s32 BgCheck_SphVsFirstPoly(CollisionContext* colCtx, Vec3f* center, f32 radius);
void SSNodeList_Initialize(SSNodeList*);
void SSNodeList_Alloc(struct GlobalContext* globalCtx, SSNodeList* thiss, s32 tblMax, s32 numPolys);
@ -281,14 +299,14 @@ void DynaPoly_Setup(struct GlobalContext* globalCtx, DynaCollisionContext* dyna)
void DynaPoly_UpdateBgActorTransforms(struct GlobalContext* globalCtx, DynaCollisionContext* dyna);
f32 BgCheck_RaycastFloorDyna(DynaRaycast* dynaRaycast);
s32 BgCheck_SphVsDynaWall(CollisionContext* colCtx, u16 xpFlags, f32* outX, f32* outZ, Vec3f* pos, f32 radius,
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor);
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor);
s32 BgCheck_CheckDynaCeiling(CollisionContext* colCtx, u16 xpFlags, f32* outY, Vec3f* pos, f32 chkDist,
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor);
CollisionPoly** outPoly, s32* outBgId, struct Actor* actor);
s32 BgCheck_CheckLineAgainstDyna(CollisionContext* colCtx, u16 xpFlags, Vec3f* posA, Vec3f* posB, Vec3f* posResult,
CollisionPoly** outPoly, f32* distSq, s32* outBgId, struct Actor* actor, f32 chkDist,
s32 bccFlags);
CollisionPoly** outPoly, f32* distSq, s32* outBgId, struct Actor* actor, f32 chkDist,
s32 bccFlags);
s32 BgCheck_SphVsFirstDynaPoly(CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId,
Vec3f* center, f32 radius, struct Actor* actor, u16 bciFlags);
Vec3f* center, f32 radius, struct Actor* actor, u16 bciFlags);
void CollisionHeader_GetVirtual(void* colHeader, CollisionHeader** dest);
void func_800418D0(CollisionContext* colCtx, struct GlobalContext* globalCtx);
void BgCheck_ResetPolyCheckTbl(SSNodeList* nodeList, s32 numPolys);
@ -321,11 +339,11 @@ u32 SurfaceType_GetConveyorSpeed(CollisionContext* colCtx, CollisionPoly* poly,
u32 SurfaceType_GetConveyorDirection(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
u32 SurfaceType_IsWallDamage(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
s32 WaterBox_GetSurface1(struct GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface,
WaterBox** outWaterBox);
WaterBox** outWaterBox);
s32 WaterBox_GetSurface2(struct GlobalContext* globalCtx, CollisionContext* colCtx, Vec3f* pos, f32 surfaceChkDist,
WaterBox** outWaterBox);
WaterBox** outWaterBox);
s32 WaterBox_GetSurfaceImpl(struct GlobalContext* globalCtx, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface,
WaterBox** outWaterBox);
WaterBox** outWaterBox);
u32 WaterBox_GetCamDataIndex(CollisionContext* colCtx, WaterBox* waterBox);
u16 WaterBox_GetCameraSType(CollisionContext* colCtx, WaterBox* waterBox);
u32 WaterBox_GetLightSettingIndex(CollisionContext* colCtx, WaterBox* waterBox);
@ -334,4 +352,3 @@ s32 func_800427B4(CollisionPoly* polyA, CollisionPoly* polyB, Vec3f* pointA, Vec
void BgCheck_DrawDynaCollision(struct GlobalContext*, CollisionContext*);
void BgCheck_DrawStaticCollision(struct GlobalContext*, CollisionContext*);
*/

1660
include/z64camera.h
View File

File diff suppressed because it is too large Load Diff

633
include/z64collision_check.h
View File

@ -6,373 +6,410 @@
#define COLLISION_CHECK_OC_MAX 50
#define COLLISION_CHECK_OC_LINE_MAX 3
struct Collider {
/* 0x00 */ struct Actor* actor; // Attached actor
/* 0x04 */ struct Actor* at; // Actor attached to what it collided with as an AT collider.
/* 0x08 */ struct Actor* ac; // Actor attached to what it collided with as an AC collider.
/* 0x0C */ struct Actor* oc; // Actor attached to what it collided with as an OC collider.
/* 0x10 */ u8 atFlags; // Information flags for AT collisions.
/* 0x11 */ u8 acFlags; // Information flags for AC collisions.
/* 0x12 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x13 */ u8 ocFlags2; // Flags related to which colliders it can OC collide with.
/* 0x14 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
/* 0x15 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x18
struct Collider
{
/* 0x00 */ struct Actor* actor; // Attached actor
/* 0x04 */ struct Actor* at; // Actor attached to what it collided with as an AT collider.
/* 0x08 */ struct Actor* ac; // Actor attached to what it collided with as an AC collider.
/* 0x0C */ struct Actor* oc; // Actor attached to what it collided with as an OC collider.
/* 0x10 */ u8 atFlags; // Information flags for AT collisions.
/* 0x11 */ u8 acFlags; // Information flags for AC collisions.
/* 0x12 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x13 */ u8 ocFlags2; // Flags related to which colliders it can OC collide with.
/* 0x14 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
/* 0x15 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x18
struct ColliderInit {
/* 0x00 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
/* 0x01 */ u8 atFlags; // Information flags for AT collisions.
/* 0x02 */ u8 acFlags; // Information flags for OC collisions.
/* 0x03 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x04 */ u8 ocFlags2; // Flags related to which colliders it can OC collide with.
/* 0x05 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x06
struct ColliderInit
{
/* 0x00 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
/* 0x01 */ u8 atFlags; // Information flags for AT collisions.
/* 0x02 */ u8 acFlags; // Information flags for OC collisions.
/* 0x03 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x04 */ u8 ocFlags2; // Flags related to which colliders it can OC collide with.
/* 0x05 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x06
struct ColliderInitType1 {
/* 0x00 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
/* 0x01 */ u8 atFlags; // Information flags for AT collisions.
/* 0x02 */ u8 acFlags; // Information flags for AC collisions.
/* 0x03 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x04 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x05
struct ColliderInitType1
{
/* 0x00 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
/* 0x01 */ u8 atFlags; // Information flags for AT collisions.
/* 0x02 */ u8 acFlags; // Information flags for AC collisions.
/* 0x03 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x04 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x05
struct ColliderInitToActor {
/* 0x00 */ struct Actor* actor;
/* 0x04 */ u8 atFlags; // Information flags for AT collisions.
/* 0x05 */ u8 acFlags; // Information flags for AC collisions.
/* 0x06 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x07 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x08
struct ColliderInitToActor
{
/* 0x00 */ struct Actor* actor;
/* 0x04 */ u8 atFlags; // Information flags for AT collisions.
/* 0x05 */ u8 acFlags; // Information flags for AC collisions.
/* 0x06 */ u8 ocFlags1; // Information flags for OC collisions.
/* 0x07 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
}; // size = 0x08
struct ColliderTouch {
/* 0x00 */ u32 dmgFlags; // Toucher damage type flags.
/* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
/* 0x05 */ u8 damage; // Damage or Stun Timer
}; // size = 0x08
struct ColliderTouch
{
/* 0x00 */ u32 dmgFlags; // Toucher damage type flags.
/* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
/* 0x05 */ u8 damage; // Damage or Stun Timer
}; // size = 0x08
struct ColliderBump {
/* 0x00 */ u32 dmgFlags; // Bumper damage type flags.
/* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
/* 0x05 */ u8 defense; // Damage Resistance
/* 0x06 */ Vec3s hitPos; // Point of contact
}; // size = 0x0C
struct ColliderBump
{
/* 0x00 */ u32 dmgFlags; // Bumper damage type flags.
/* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
/* 0x05 */ u8 defense; // Damage Resistance
/* 0x06 */ Vec3s hitPos; // Point of contact
}; // size = 0x0C
struct ColliderBumpInit {
/* 0x00 */ u32 dmgFlags; // Bumper exclusion mask
/* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
/* 0x05 */ u8 defense; // Damage Resistance
}; // size = 0x08
struct ColliderBumpInit
{
/* 0x00 */ u32 dmgFlags; // Bumper exclusion mask
/* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
/* 0x05 */ u8 defense; // Damage Resistance
}; // size = 0x08
struct ColliderInfo {
/* 0x00 */ ColliderTouch toucher; // Damage properties when acting as an AT collider
/* 0x08 */ ColliderBump bumper; // Damage properties when acting as an AC collider
/* 0x14 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
/* 0x15 */ u8 toucherFlags; // Information flags for AT collisions
/* 0x16 */ u8 bumperFlags; // Information flags for AC collisions
/* 0x17 */ u8 ocElemFlags; // Information flags for OC collisions
/* 0x18 */ Collider* atHit; // object touching this element's AT collider
/* 0x1C */ Collider* acHit; // object touching this element's AC collider
/* 0x20 */ struct ColliderInfo* atHitInfo; // element that hit the AT collider
/* 0x24 */ struct ColliderInfo* acHitInfo; // element that hit the AC collider
}; // size = 0x28
struct ColliderInfo
{
/* 0x00 */ ColliderTouch toucher; // Damage properties when acting as an AT collider
/* 0x08 */ ColliderBump bumper; // Damage properties when acting as an AC collider
/* 0x14 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
/* 0x15 */ u8 toucherFlags; // Information flags for AT collisions
/* 0x16 */ u8 bumperFlags; // Information flags for AC collisions
/* 0x17 */ u8 ocElemFlags; // Information flags for OC collisions
/* 0x18 */ Collider* atHit; // object touching this element's AT collider
/* 0x1C */ Collider* acHit; // object touching this element's AC collider
/* 0x20 */ struct ColliderInfo* atHitInfo; // element that hit the AT collider
/* 0x24 */ struct ColliderInfo* acHitInfo; // element that hit the AC collider
}; // size = 0x28
struct ColliderInfoInit {
/* 0x00 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
/* 0x04 */ ColliderTouch toucher; // Damage properties when acting as an AT collider
/* 0x0C */ ColliderBumpInit bumper; // Damage properties when acting as an AC collider
/* 0x14 */ u8 toucherFlags; // Information flags for AT collisions
/* 0x15 */ u8 bumperFlags; // Information flags for AC collisions
/* 0x16 */ u8 ocElemFlags; // Information flags for OC collisions
}; // size = 0x18
struct ColliderInfoInit
{
/* 0x00 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
/* 0x04 */ ColliderTouch toucher; // Damage properties when acting as an AT collider
/* 0x0C */ ColliderBumpInit bumper; // Damage properties when acting as an AC collider
/* 0x14 */ u8 toucherFlags; // Information flags for AT collisions
/* 0x15 */ u8 bumperFlags; // Information flags for AC collisions
/* 0x16 */ u8 ocElemFlags; // Information flags for OC collisions
}; // size = 0x18
struct ColliderJntSphElementDim {
/* 0x00 */ Sphere16 modelSphere; // model space sphere
/* 0x08 */ Sphere16 worldSphere; // world space sphere
/* 0x10 */ f32 scale; // world space sphere = model * scale * 0.01
/* 0x14 */ u8 limb; // attached limb
}; // size = 0x18
struct ColliderJntSphElementDim
{
/* 0x00 */ Sphere16 modelSphere; // model space sphere
/* 0x08 */ Sphere16 worldSphere; // world space sphere
/* 0x10 */ f32 scale; // world space sphere = model * scale * 0.01
/* 0x14 */ u8 limb; // attached limb
}; // size = 0x18
struct ColliderJntSphElementDimInit {
/* 0x00 */ u8 limb; // attached limb
/* 0x02 */ Sphere16 modelSphere; // model space sphere
/* 0x0A */ s16 scale; // world space sphere = model * scale * 0.01
}; // size = 0x0C
struct ColliderJntSphElementDimInit
{
/* 0x00 */ u8 limb; // attached limb
/* 0x02 */ Sphere16 modelSphere; // model space sphere
/* 0x0A */ s16 scale; // world space sphere = model * scale * 0.01
}; // size = 0x0C
struct ColliderJntSphElement {
/* 0x00 */ ColliderInfo info;
/* 0x28 */ ColliderJntSphElementDim dim;
struct ColliderJntSphElement
{
/* 0x00 */ ColliderInfo info;
/* 0x28 */ ColliderJntSphElementDim dim;
}; // size = 0x40
struct ColliderJntSphElementInit {
/* 0x00 */ ColliderInfoInit info;
/* 0x18 */ ColliderJntSphElementDimInit dim;
struct ColliderJntSphElementInit
{
/* 0x00 */ ColliderInfoInit info;
/* 0x18 */ ColliderJntSphElementDimInit dim;
}; // size = 0x24
struct ColliderJntSph {
/* 0x00 */ Collider base;
/* 0x18 */ s32 count;
/* 0x1C */ ColliderJntSphElement* elements;
struct ColliderJntSph
{
/* 0x00 */ Collider base;
/* 0x18 */ s32 count;
/* 0x1C */ ColliderJntSphElement* elements;
}; // size = 0x20
struct ColliderJntSphInit {
/* 0x00 */ ColliderInit base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderJntSphElementInit* elements;
struct ColliderJntSphInit
{
/* 0x00 */ ColliderInit base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderJntSphElementInit* elements;
}; // size = 0x10
struct ColliderJntSphInitType1 {
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderJntSphElementInit* elements;
struct ColliderJntSphInitType1
{
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderJntSphElementInit* elements;
}; // size = 0x10
struct ColliderJntSphInitToActor {
/* 0x00 */ ColliderInitToActor base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderJntSphElementInit* elements;
struct ColliderJntSphInitToActor
{
/* 0x00 */ ColliderInitToActor base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderJntSphElementInit* elements;
}; // size = 0x10
struct ColliderCylinder {
/* 0x00 */ Collider base;
/* 0x18 */ ColliderInfo info;
/* 0x40 */ Cylinder16 dim;
struct ColliderCylinder
{
/* 0x00 */ Collider base;
/* 0x18 */ ColliderInfo info;
/* 0x40 */ Cylinder16 dim;
}; // size = 0x4C
struct ColliderCylinderInit {
/* 0x00 */ ColliderInit base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ Cylinder16 dim;
struct ColliderCylinderInit
{
/* 0x00 */ ColliderInit base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ Cylinder16 dim;
}; // size = 0x2C
struct ColliderCylinderInitType1 {
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ Cylinder16 dim;
struct ColliderCylinderInitType1
{
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ Cylinder16 dim;
}; // size = 0x2C
struct ColliderCylinderInitToActor {
/* 0x00 */ ColliderInitToActor base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ Cylinder16 dim;
struct ColliderCylinderInitToActor
{
/* 0x00 */ ColliderInitToActor base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ Cylinder16 dim;
}; // size = 0x2C
struct ColliderTrisElementDimInit {
/* 0x00 */ Vec3f vtx[3];
struct ColliderTrisElementDimInit
{
/* 0x00 */ Vec3f vtx[3];
}; // size = 0x24
struct ColliderTrisElement {
/* 0x00 */ ColliderInfo info;
/* 0x28 */ TriNorm dim;
struct ColliderTrisElement
{
/* 0x00 */ ColliderInfo info;
/* 0x28 */ TriNorm dim;
}; // size = 0x5C
struct ColliderTrisElementInit {
/* 0x00 */ ColliderInfoInit info;
/* 0x18 */ ColliderTrisElementDimInit dim;
struct ColliderTrisElementInit
{
/* 0x00 */ ColliderInfoInit info;
/* 0x18 */ ColliderTrisElementDimInit dim;
}; // size = 0x3C
struct ColliderTris {
/* 0x00 */ Collider base;
/* 0x18 */ s32 count;
/* 0x1C */ ColliderTrisElement* elements;
struct ColliderTris
{
/* 0x00 */ Collider base;
/* 0x18 */ s32 count;
/* 0x1C */ ColliderTrisElement* elements;
}; // size = 0x20
struct ColliderTrisInit {
/* 0x00 */ ColliderInit base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderTrisElementInit* elements;
struct ColliderTrisInit
{
/* 0x00 */ ColliderInit base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderTrisElementInit* elements;
}; // size = 0x10
struct ColliderTrisInitType1 {
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderTrisElementInit* elements;
struct ColliderTrisInitType1
{
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ s32 count;
/* 0x0C */ ColliderTrisElementInit* elements;
}; // size = 0x10
struct ColliderQuadDim {
/* 0x00 */ Vec3f quad[4];
/* 0x30 */ Vec3s dcMid; // midpoint of vectors d, c
/* 0x36 */ Vec3s baMid; // midpoint of vectors b, a
/* 0x3C */ f32 acDist; // distance to nearest AC collision this frame.
}; // size = 0x40
struct ColliderQuadDim
{
/* 0x00 */ Vec3f quad[4];
/* 0x30 */ Vec3s dcMid; // midpoint of vectors d, c
/* 0x36 */ Vec3s baMid; // midpoint of vectors b, a
/* 0x3C */ f32 acDist; // distance to nearest AC collision this frame.
}; // size = 0x40
struct ColliderQuadDimInit {
/* 0x00 */ Vec3f quad[4];
struct ColliderQuadDimInit
{
/* 0x00 */ Vec3f quad[4];
}; // size = 0x30
struct ColliderQuadElement {
/* 0x00 */ ColliderInfo info;
/* 0x24 */ ColliderQuadDim dim;
struct ColliderQuadElement
{
/* 0x00 */ ColliderInfo info;
/* 0x24 */ ColliderQuadDim dim;
}; // size = 0x68
struct ColliderQuad {
/* 0x00 */ Collider base;
/* 0x18 */ ColliderInfo info;
/* 0x40 */ ColliderQuadDim dim;
struct ColliderQuad
{
/* 0x00 */ Collider base;
/* 0x18 */ ColliderInfo info;
/* 0x40 */ ColliderQuadDim dim;
}; // size = 0x80
struct ColliderQuadInit {
/* 0x00 */ ColliderInit base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ ColliderQuadDimInit dim;
struct ColliderQuadInit
{
/* 0x00 */ ColliderInit base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ ColliderQuadDimInit dim;
}; // size = 0x50
struct ColliderQuadInitType1 {
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ ColliderQuadDimInit dim;
struct ColliderQuadInitType1
{
/* 0x00 */ ColliderInitType1 base;
/* 0x08 */ ColliderInfoInit info;
/* 0x20 */ ColliderQuadDimInit dim;
}; // size = 0x50
struct OcLine {
/* 0x00 */ Linef line;
/* 0x18 */ u16 ocFlags;
struct OcLine
{
/* 0x00 */ Linef line;
/* 0x18 */ u16 ocFlags;
}; // size = 0x1C
enum ColliderType {
/* 0 */ COLTYPE_HIT0, // Blue blood, white hitmark
/* 1 */ COLTYPE_HIT1, // No blood, dust hitmark
/* 2 */ COLTYPE_HIT2, // Green blood, dust hitmark
/* 3 */ COLTYPE_HIT3, // No blood, white hitmark
/* 4 */ COLTYPE_HIT4, // Water burst, no hitmark
/* 5 */ COLTYPE_HIT5, // No blood, red hitmark
/* 6 */ COLTYPE_HIT6, // Green blood, white hitmark
/* 7 */ COLTYPE_HIT7, // Red blood, white hitmark
/* 8 */ COLTYPE_HIT8, // Blue blood, red hitmark
/* 9 */ COLTYPE_METAL,
/* 10 */ COLTYPE_NONE,
/* 11 */ COLTYPE_WOOD,
/* 12 */ COLTYPE_HARD,
/* 13 */ COLTYPE_TREE
enum ColliderType
{
/* 0 */ COLTYPE_HIT0, // Blue blood, white hitmark
/* 1 */ COLTYPE_HIT1, // No blood, dust hitmark
/* 2 */ COLTYPE_HIT2, // Green blood, dust hitmark
/* 3 */ COLTYPE_HIT3, // No blood, white hitmark
/* 4 */ COLTYPE_HIT4, // Water burst, no hitmark
/* 5 */ COLTYPE_HIT5, // No blood, red hitmark
/* 6 */ COLTYPE_HIT6, // Green blood, white hitmark
/* 7 */ COLTYPE_HIT7, // Red blood, white hitmark
/* 8 */ COLTYPE_HIT8, // Blue blood, red hitmark
/* 9 */ COLTYPE_METAL,
/* 10 */ COLTYPE_NONE,
/* 11 */ COLTYPE_WOOD,
/* 12 */ COLTYPE_HARD,
/* 13 */ COLTYPE_TREE
};
enum ColliderShape {
/* 0 */ COLSHAPE_JNTSPH,
/* 1 */ COLSHAPE_CYLINDER,
/* 2 */ COLSHAPE_TRIS,
/* 3 */ COLSHAPE_QUAD,
/* 4 */ COLSHAPE_INVALID
enum ColliderShape
{
/* 0 */ COLSHAPE_JNTSPH,
/* 1 */ COLSHAPE_CYLINDER,
/* 2 */ COLSHAPE_TRIS,
/* 3 */ COLSHAPE_QUAD,
/* 4 */ COLSHAPE_INVALID
};
/**
* Affects the sound Link's sword makes when hitting it, hookability,
* and possibly other things. It's definitely not flags, as all checks
* are == or !=. Will probably need more actors decomped to truly
* are == or !=. Will probably need more actors decomped to truly
* understand what this is.
*/
enum ElementType {
/* 0 */ ELEMTYPE_UNK0,
/* 1 */ ELEMTYPE_UNK1,
/* 2 */ ELEMTYPE_UNK2,
/* 3 */ ELEMTYPE_UNK3,
/* 4 */ ELEMTYPE_UNK4,
/* 5 */ ELEMTYPE_UNK5,
/* 6 */ ELEMTYPE_UNK6,
/* 7 */ ELEMTYPE_UNK7
enum ElementType
{
/* 0 */ ELEMTYPE_UNK0,
/* 1 */ ELEMTYPE_UNK1,
/* 2 */ ELEMTYPE_UNK2,
/* 3 */ ELEMTYPE_UNK3,
/* 4 */ ELEMTYPE_UNK4,
/* 5 */ ELEMTYPE_UNK5,
/* 6 */ ELEMTYPE_UNK6,
/* 7 */ ELEMTYPE_UNK7
};
#define AT_NONE 0 // No flags set. Cannot have AT collisions when set as AT
#define AT_ON (1 << 0) // Can have AT collisions when set as AT
#define AT_HIT (1 << 1) // Had an AT collision
#define AT_BOUNCED (1 << 2) // Had an AT collision with an AC_HARD collider
#define AT_TYPE_PLAYER (1 << 3) // Has player-aligned damage
#define AT_TYPE_ENEMY (1 << 4) // Has enemy-aligned damage
#define AT_TYPE_OTHER (1 << 5) // Has non-aligned damage
#define AT_SELF (1 << 6) // Can have AT collisions with colliders attached to the same actor
#define AT_NONE 0 // No flags set. Cannot have AT collisions when set as AT
#define AT_ON (1 << 0) // Can have AT collisions when set as AT
#define AT_HIT (1 << 1) // Had an AT collision
#define AT_BOUNCED (1 << 2) // Had an AT collision with an AC_HARD collider
#define AT_TYPE_PLAYER (1 << 3) // Has player-aligned damage
#define AT_TYPE_ENEMY (1 << 4) // Has enemy-aligned damage
#define AT_TYPE_OTHER (1 << 5) // Has non-aligned damage
#define AT_SELF (1 << 6) // Can have AT collisions with colliders attached to the same actor
#define AT_TYPE_ALL (AT_TYPE_PLAYER | AT_TYPE_ENEMY | AT_TYPE_OTHER) // Has all three damage alignments
#define AC_NONE 0 // No flags set. Cannot have AC collisions when set as AC
#define AC_ON (1 << 0) // Can have AC collisions when set as AC
#define AC_HIT (1 << 1) // Had an AC collision
#define AC_HARD (1 << 2) // Causes AT colliders to bounce off it
#define AC_TYPE_PLAYER AT_TYPE_PLAYER // Takes player-aligned damage
#define AC_TYPE_ENEMY AT_TYPE_ENEMY // Takes enemy-aligned damage
#define AC_TYPE_OTHER AT_TYPE_OTHER // Takes non-aligned damage
#define AC_NO_DAMAGE (1 << 6) // Collider does not take damage
#define AC_BOUNCED (1 << 7) // Caused an AT collider to bounce off it
#define AC_NONE 0 // No flags set. Cannot have AC collisions when set as AC
#define AC_ON (1 << 0) // Can have AC collisions when set as AC
#define AC_HIT (1 << 1) // Had an AC collision
#define AC_HARD (1 << 2) // Causes AT colliders to bounce off it
#define AC_TYPE_PLAYER AT_TYPE_PLAYER // Takes player-aligned damage
#define AC_TYPE_ENEMY AT_TYPE_ENEMY // Takes enemy-aligned damage
#define AC_TYPE_OTHER AT_TYPE_OTHER // Takes non-aligned damage
#define AC_NO_DAMAGE (1 << 6) // Collider does not take damage
#define AC_BOUNCED (1 << 7) // Caused an AT collider to bounce off it
#define AC_TYPE_ALL (AC_TYPE_PLAYER | AC_TYPE_ENEMY | AC_TYPE_OTHER) // Takes damage from all three alignments
#define OC1_NONE 0 // No flags set. Cannot have OC collisions when set as OC
#define OC1_ON (1 << 0) // Can have OC collisions when set as OC
#define OC1_HIT (1 << 1) // Had an OC collision
#define OC1_NO_PUSH (1 << 2) // Does not push other colliders away during OC collisions
#define OC1_TYPE_PLAYER (1 << 3) // Can have OC collisions with OC type player
#define OC1_TYPE_1 (1 << 4) // Can have OC collisions with OC type 1
#define OC1_TYPE_2 (1 << 5) // Can have OC collisions with OC type 2
#define OC1_NONE 0 // No flags set. Cannot have OC collisions when set as OC
#define OC1_ON (1 << 0) // Can have OC collisions when set as OC
#define OC1_HIT (1 << 1) // Had an OC collision
#define OC1_NO_PUSH (1 << 2) // Does not push other colliders away during OC collisions
#define OC1_TYPE_PLAYER (1 << 3) // Can have OC collisions with OC type player
#define OC1_TYPE_1 (1 << 4) // Can have OC collisions with OC type 1
#define OC1_TYPE_2 (1 << 5) // Can have OC collisions with OC type 2
#define OC1_TYPE_ALL (OC1_TYPE_PLAYER | OC1_TYPE_1 | OC1_TYPE_2) // Can have collisions with all three OC types
#define OC2_NONE 0 // No flags set. Has no OC type
#define OC2_HIT_PLAYER (1 << 0) // Had an OC collision with OC type player
#define OC2_UNK1 (1 << 1) // Prevents OC collisions with OC2_UNK2. Some horses and toki_sword have it.
#define OC2_UNK2 (1 << 2) // Prevents OC collisions with OC2_UNK1. Nothing has it.
#define OC2_NONE 0 // No flags set. Has no OC type
#define OC2_HIT_PLAYER (1 << 0) // Had an OC collision with OC type player
#define OC2_UNK1 (1 << 1) // Prevents OC collisions with OC2_UNK2. Some horses and toki_sword have it.
#define OC2_UNK2 (1 << 2) // Prevents OC collisions with OC2_UNK1. Nothing has it.
#define OC2_TYPE_PLAYER OC1_TYPE_PLAYER // Has OC type player
#define OC2_TYPE_1 OC1_TYPE_1 // Has OC type 1
#define OC2_TYPE_2 OC1_TYPE_2 // Has OC type 2
#define OC2_FIRST_ONLY (1 << 6) // Skips AC checks on elements after the first collision. Only used by Ganon
#define OC2_TYPE_1 OC1_TYPE_1 // Has OC type 1
#define OC2_TYPE_2 OC1_TYPE_2 // Has OC type 2
#define OC2_FIRST_ONLY (1 << 6) // Skips AC checks on elements after the first collision. Only used by Ganon
#define TOUCH_NONE 0 // No flags set. Cannot have AT collisions
#define TOUCH_ON (1 << 0) // Can have AT collisions
#define TOUCH_HIT (1 << 1) // Had an AT collision
#define TOUCH_NEAREST (1 << 2) // If a Quad, only collides with the closest bumper
#define TOUCH_SFX_NORMAL (0 << 3) // Hit sound effect based on AC collider's type
#define TOUCH_SFX_HARD (1 << 3) // Always uses hard deflection sound
#define TOUCH_SFX_WOOD (2 << 3) // Always uses wood deflection sound
#define TOUCH_SFX_NONE (3 << 3) // No hit sound effect
#define TOUCH_AT_HITMARK (1 << 5) // Draw hitmarks for every AT collision
#define TOUCH_NONE 0 // No flags set. Cannot have AT collisions
#define TOUCH_ON (1 << 0) // Can have AT collisions
#define TOUCH_HIT (1 << 1) // Had an AT collision
#define TOUCH_NEAREST (1 << 2) // If a Quad, only collides with the closest bumper
#define TOUCH_SFX_NORMAL (0 << 3) // Hit sound effect based on AC collider's type
#define TOUCH_SFX_HARD (1 << 3) // Always uses hard deflection sound
#define TOUCH_SFX_WOOD (2 << 3) // Always uses wood deflection sound
#define TOUCH_SFX_NONE (3 << 3) // No hit sound effect
#define TOUCH_AT_HITMARK (1 << 5) // Draw hitmarks for every AT collision
#define TOUCH_DREW_HITMARK (1 << 6) // Already drew hitmark for this frame
#define TOUCH_UNK7 (1 << 7) // Unknown purpose. Used by some enemy quads
#define TOUCH_UNK7 (1 << 7) // Unknown purpose. Used by some enemy quads
#define BUMP_NONE 0 // No flags set. Cannot have AC collisions
#define BUMP_ON (1 << 0) // Can have AC collisions
#define BUMP_HIT (1 << 1) // Had an AC collision
#define BUMP_HOOKABLE (1 << 2) // Can be hooked if actor has hookability flags set.
#define BUMP_NO_AT_INFO (1 << 3) // Does not give its info to the AT collider that hit it.
#define BUMP_NO_DAMAGE (1 << 4) // Does not take damage.
#define BUMP_NONE 0 // No flags set. Cannot have AC collisions
#define BUMP_ON (1 << 0) // Can have AC collisions
#define BUMP_HIT (1 << 1) // Had an AC collision
#define BUMP_HOOKABLE (1 << 2) // Can be hooked if actor has hookability flags set.
#define BUMP_NO_AT_INFO (1 << 3) // Does not give its info to the AT collider that hit it.
#define BUMP_NO_DAMAGE (1 << 4) // Does not take damage.
#define BUMP_NO_SWORD_SFX (1 << 5) // Does not have a sound when hit by player-attached AT colliders.
#define BUMP_NO_HITMARK (1 << 6) // Skips hit effects.
#define BUMP_NO_HITMARK (1 << 6) // Skips hit effects.
#define BUMP_DRAW_HITMARK (1 << 7) // Draw hitmark for AC collision this frame.
#define OCELEM_NONE 0 // No flags set. Cannot have OC collisions
#define OCELEM_ON (1 << 0) // Can have OC collisions
#define OCELEM_HIT (1 << 1) // Had an OC collision
#define OCELEM_NONE 0 // No flags set. Cannot have OC collisions
#define OCELEM_ON (1 << 0) // Can have OC collisions
#define OCELEM_HIT (1 << 1) // Had an OC collision
#define OCELEM_UNK3 (1 << 3) // Unknown purpose. Used by Dead Hand element 0 and Dodongo element 5
#define OCLINE_NONE 0 // Did not have an OcLine collision
#define OCLINE_NONE 0 // Did not have an OcLine collision
#define OCLINE_HIT (1 << 0) // Had an OcLine collision
#define DMG_ENTRY(damage, effect) ((damage) | ((effect) << 4))
// These flags are not to be used in code until we figure out how we want to format them. They are only here for reference
#define DMG_DEKU_NUT (1 << 0x00)
#define DMG_DEKU_STICK (1 << 0x01)
#define DMG_SLINGSHOT (1 << 0x02)
#define DMG_EXPLOSIVE (1 << 0x03)
#define DMG_BOOMERANG (1 << 0x04)
// These flags are not to be used in code until we figure out how we want to format them. They are only here for reference
#define DMG_DEKU_NUT (1 << 0x00)
#define DMG_DEKU_STICK (1 << 0x01)
#define DMG_SLINGSHOT (1 << 0x02)
#define DMG_EXPLOSIVE (1 << 0x03)
#define DMG_BOOMERANG (1 << 0x04)
#define DMG_ARROW_NORMAL (1 << 0x05)
#define DMG_HAMMER_SWING (1 << 0x06)
#define DMG_HOOKSHOT (1 << 0x07)
#define DMG_HOOKSHOT (1 << 0x07)
#define DMG_SLASH_KOKIRI (1 << 0x08)
#define DMG_SLASH_MASTER (1 << 0x09)
#define DMG_SLASH_GIANT (1 << 0x0A)
#define DMG_ARROW_FIRE (1 << 0x0B)
#define DMG_ARROW_ICE (1 << 0x0C)
#define DMG_ARROW_LIGHT (1 << 0x0D)
#define DMG_ARROW_UNK1 (1 << 0x0E)
#define DMG_ARROW_UNK2 (1 << 0x0F)
#define DMG_ARROW_UNK3 (1 << 0x10)
#define DMG_MAGIC_FIRE (1 << 0x11)
#define DMG_MAGIC_ICE (1 << 0x12)
#define DMG_MAGIC_LIGHT (1 << 0x13)
#define DMG_SHIELD (1 << 0x14)
#define DMG_MIR_RAY (1 << 0x15)
#define DMG_SPIN_KOKIRI (1 << 0x16)
#define DMG_SPIN_GIANT (1 << 0x17)
#define DMG_SPIN_MASTER (1 << 0x18)
#define DMG_JUMP_KOKIRI (1 << 0x19)
#define DMG_JUMP_GIANT (1 << 0x1A)
#define DMG_JUMP_MASTER (1 << 0x1B)
#define DMG_UNKNOWN_1 (1 << 0x1C)
#define DMG_UNBLOCKABLE (1 << 0x1D)
#define DMG_HAMMER_JUMP (1 << 0x1E)
#define DMG_UNKNOWN_2 (1 << 0x1F)
#define DMG_SLASH_GIANT (1 << 0x0A)
#define DMG_ARROW_FIRE (1 << 0x0B)
#define DMG_ARROW_ICE (1 << 0x0C)
#define DMG_ARROW_LIGHT (1 << 0x0D)
#define DMG_ARROW_UNK1 (1 << 0x0E)
#define DMG_ARROW_UNK2 (1 << 0x0F)
#define DMG_ARROW_UNK3 (1 << 0x10)
#define DMG_MAGIC_FIRE (1 << 0x11)
#define DMG_MAGIC_ICE (1 << 0x12)
#define DMG_MAGIC_LIGHT (1 << 0x13)
#define DMG_SHIELD (1 << 0x14)
#define DMG_MIR_RAY (1 << 0x15)
#define DMG_SPIN_KOKIRI (1 << 0x16)
#define DMG_SPIN_GIANT (1 << 0x17)
#define DMG_SPIN_MASTER (1 << 0x18)
#define DMG_JUMP_KOKIRI (1 << 0x19)
#define DMG_JUMP_GIANT (1 << 0x1A)
#define DMG_JUMP_MASTER (1 << 0x1B)
#define DMG_UNKNOWN_1 (1 << 0x1C)
#define DMG_UNBLOCKABLE (1 << 0x1D)
#define DMG_HAMMER_JUMP (1 << 0x1E)
#define DMG_UNKNOWN_2 (1 << 0x1F)
#define DMG_SLASH (DMG_SLASH_KOKIRI | DMG_SLASH_MASTER | DMG_SLASH_GIANT)
#define DMG_SPIN_ATTACK (DMG_SPIN_KOKIRI | DMG_SPIN_MASTER | DMG_SPIN_GIANT)
@ -384,39 +421,35 @@ enum ElementType {
#define DMG_RANGED (DMG_ARROW | DMG_HOOKSHOT | DMG_SLINGSHOT)
#define DMG_DEFAULT ~(DMG_SHIELD | DMG_MIR_RAY)
struct CollisionCheckContext {
/* 0x000 */ s16 colATCount;
/* 0x002 */ u16 sacFlags;
/* 0x004 */ Collider* colAT[COLLISION_CHECK_AT_MAX];
/* 0x0CC */ s32 colACCount;
/* 0x0D0 */ Collider* colAC[COLLISION_CHECK_AC_MAX];
/* 0x1C0 */ s32 colOCCount;
/* 0x1C4 */ Collider* colOC[COLLISION_CHECK_OC_MAX];
/* 0x28C */ s32 colLineCount;
/* 0x290 */ OcLine* colLine[COLLISION_CHECK_OC_LINE_MAX];
struct CollisionCheckContext
{
/* 0x000 */ s16 colATCount;
/* 0x002 */ u16 sacFlags;
/* 0x004 */ Collider* colAT[COLLISION_CHECK_AT_MAX];
/* 0x0CC */ s32 colACCount;
/* 0x0D0 */ Collider* colAC[COLLISION_CHECK_AC_MAX];
/* 0x1C0 */ s32 colOCCount;
/* 0x1C4 */ Collider* colOC[COLLISION_CHECK_OC_MAX];
/* 0x28C */ s32 colLineCount;
/* 0x290 */ OcLine* colLine[COLLISION_CHECK_OC_LINE_MAX];
}; // size = 0x29C
void Collider_DrawRedPoly(struct GraphicsContext* gfxCtx, Vec3f* vA, Vec3f* vB, Vec3f* vC);
void Collider_DrawPoly(struct GraphicsContext* gfxCtx, Vec3f* vA, Vec3f* vB, Vec3f* vC, u8 r, u8 g, u8 b);
s32 Collider_InitJntSph(struct GlobalContext* globalCtx, ColliderJntSph* collider);
s32 Collider_FreeJntSph(struct GlobalContext* globalCtx, ColliderJntSph* collider);
s32 Collider_DestroyJntSph(struct GlobalContext* globalCtx, ColliderJntSph* collider);
s32 Collider_SetJntSphToActor(struct GlobalContext* globalCtx, ColliderJntSph* dest, ColliderJntSphInitToActor* src);
s32 Collider_SetJntSphAllocType1(struct GlobalContext* globalCtx, ColliderJntSph* dest, struct Actor* actor,
ColliderJntSphInitType1* src);
s32 Collider_SetJntSphAllocType1(struct GlobalContext* globalCtx, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInitType1* src);
s32 Collider_SetJntSphAlloc(struct GlobalContext* globalCtx, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInit* src);
s32 Collider_SetJntSph(struct GlobalContext* globalCtx, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInit* src,
ColliderJntSphElement* elements);
s32 Collider_SetJntSph(struct GlobalContext* globalCtx, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInit* src, ColliderJntSphElement* elements);
s32 Collider_ResetJntSphAT(struct GlobalContext* globalCtx, Collider* collider);
s32 Collider_ResetJntSphAC(struct GlobalContext* globalCtx, Collider* collider);
s32 Collider_ResetJntSphOC(struct GlobalContext* globalCtx, Collider* collider);
s32 Collider_InitCylinder(struct GlobalContext* globalCtx, ColliderCylinder* collider);
s32 Collider_DestroyCylinder(struct GlobalContext* globalCtx, ColliderCylinder* collider);
s32 Collider_SetCylinderToActor(struct GlobalContext* globalCtx, ColliderCylinder* collider, ColliderCylinderInitToActor* src);
s32 Collider_SetCylinderType1(struct GlobalContext* globalCtx, ColliderCylinder* collider, struct Actor* actor,
ColliderCylinderInitType1* src);
s32 Collider_SetCylinderType1(struct GlobalContext* globalCtx, ColliderCylinder* collider, struct Actor* actor, ColliderCylinderInitType1* src);
s32 Collider_SetCylinder(struct GlobalContext* globalCtx, ColliderCylinder* collider, struct Actor* actor, ColliderCylinderInit* src);
s32 Collider_ResetCylinderAT(struct GlobalContext* globalCtx, Collider* collider);
s32 Collider_ResetCylinderAC(struct GlobalContext* globalCtx, Collider* collider);
@ -426,8 +459,7 @@ s32 Collider_FreeTris(struct GlobalContext* globalCtx, ColliderTris* tris);
s32 Collider_DestroyTris(struct GlobalContext* globalCtx, ColliderTris* tris);
s32 Collider_SetTrisAllocType1(struct GlobalContext* globalCtx, ColliderTris* dest, struct Actor* actor, ColliderTrisInitType1* src);
s32 Collider_SetTrisAlloc(struct GlobalContext* globalCtx, ColliderTris* dest, struct Actor* actor, ColliderTrisInit* src);
s32 Collider_SetTris(struct GlobalContext* globalCtx, ColliderTris* dest, struct Actor* actor, ColliderTrisInit* src,
ColliderTrisElement* elements);
s32 Collider_SetTris(struct GlobalContext* globalCtx, ColliderTris* dest, struct Actor* actor, ColliderTrisInit* src, ColliderTrisElement* elements);
s32 Collider_ResetTrisAT(struct GlobalContext* globalCtx, Collider* collider);
s32 Collider_ResetTrisAC(struct GlobalContext* globalCtx, Collider* collider);
s32 Collider_ResetTrisOC(struct GlobalContext* globalCtx, Collider* collider);
@ -468,8 +500,7 @@ void CollisionCheck_SetInfo2(struct CollisionCheckInfo* info, struct DamageTable
void CollisionCheck_SetInfoGetDamageTable(struct CollisionCheckInfo* info, s32 index, struct CollisionCheckInfoInit2* init);
void CollisionCheck_Damage(struct GlobalContext* globalCtx, CollisionCheckContext* colChkCtx);
s32 CollisionCheck_LineOCCheckAll(struct GlobalContext* globalCtx, CollisionCheckContext* colChkCtx, Vec3f* a, Vec3f* b);
s32 CollisionCheck_LineOCCheck(struct GlobalContext* globalCtx, CollisionCheckContext* colChkCtx, Vec3f* a, Vec3f* b,
struct Actor** exclusions, s32 numExclusions);
s32 CollisionCheck_LineOCCheck(struct GlobalContext* globalCtx, CollisionCheckContext* colChkCtx, Vec3f* a, Vec3f* b, struct Actor** exclusions, s32 numExclusions);
void Collider_UpdateCylinder(struct Actor* actor, ColliderCylinder* collider);
void Collider_SetCylinderPosition(ColliderCylinder* collider, Vec3s* pos);
void Collider_SetQuadVertices(ColliderQuad* collider, Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* d);
@ -483,7 +514,5 @@ void CollisionCheck_SpawnShieldParticlesMetal(struct GlobalContext* globalCtx, V
void CollisionCheck_SpawnShieldParticlesMetalSound(struct GlobalContext* globalCtx, Vec3f* v, Vec3f* actorPos);
void CollisionCheck_SpawnShieldParticlesMetal2(struct GlobalContext* globalCtx, Vec3f* v);
void CollisionCheck_SpawnShieldParticlesWood(struct GlobalContext* globalCtx, Vec3f* b, Vec3f* actorPos);
s32 CollisionCheck_CylSideVsLineSeg(f32 radius, f32 height, f32 offset, Vec3f* actorPos, Vec3f* itemPos,
Vec3f* itemProjPos, Vec3f* out1, Vec3f* out2);
s32 CollisionCheck_CylSideVsLineSeg(f32 radius, f32 height, f32 offset, Vec3f* actorPos, Vec3f* itemPos, Vec3f* itemProjPos, Vec3f* out1, Vec3f* out2);
u8 CollisionCheck_GetSwordDamage(s32 dmgFlags);

522
include/z64cutscene.h
View File

@ -1,303 +1,321 @@
#pragma once
#include "framerate.h"
#include "ultra64.h"
#include "z64math.h"
#include "framerate.h"
struct EntranceCutscene {
/* 0x00 */ u16 entrance; // entrance index upon which the cutscene should trigger
/* 0x02 */ u8 ageRestriction; // 0 for adult only, 1 for child only, 2 for both ages
/* 0x03 */ u8 flag; // eventChkInf flag bound to the entrance cutscene
/* 0x04 */ void* segAddr; // segment offset location of the cutscene
}; // size = 0x8
struct EntranceCutscene
{
/* 0x00 */ u16 entrance; // entrance index upon which the cutscene should trigger
/* 0x02 */ u8 ageRestriction; // 0 for adult only, 1 for child only, 2 for both ages
/* 0x03 */ u8 flag; // eventChkInf flag bound to the entrance cutscene
/* 0x04 */ void* segAddr; // segment offset location of the cutscene
}; // size = 0x8
struct CutsceneCameraPoint {
/* 0x00 */ s8 continueFlag;
/* 0x01 */ s8 cameraRoll;
/* 0x02 */ u16 nextPointFrame;
/* 0x04 */ f32 viewAngle; // in degrees
/* 0x08 */ Vec3s pos;
struct CutsceneCameraPoint
{
/* 0x00 */ s8 continueFlag;
/* 0x01 */ s8 cameraRoll;
/* 0x02 */ u16 nextPointFrame;
/* 0x04 */ f32 viewAngle; // in degrees
/* 0x08 */ Vec3s pos;
}; // size = 0x10
struct CutsceneCameraAngle {
/* 0x00 */ Vec3f at;
/* 0x0C */ Vec3f eye;
/* 0x18 */ s16 roll;
/* 0x1A */ s16 fov;
struct CutsceneCameraAngle
{
/* 0x00 */ Vec3f at;
/* 0x0C */ Vec3f eye;
/* 0x18 */ s16 roll;
/* 0x1A */ s16 fov;
}; // size = 0x1C
struct CutsceneCameraMove {
/* 0x0 */ CutsceneCameraPoint* atPoints;
/* 0x4 */ CutsceneCameraPoint* eyePoints;
/* 0x8 */ s16 relativeToPlayer;
struct CutsceneCameraMove
{
/* 0x0 */ CutsceneCameraPoint* atPoints;
/* 0x4 */ CutsceneCameraPoint* eyePoints;
/* 0x8 */ s16 relativeToPlayer;
}; // size = 0xC
struct CsCmdBase {
/* 0x00 */ u16 base;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
struct CsCmdBase
{
/* 0x00 */ u16 base;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
}; // size = 0x6
struct CsCmdEnvLighting {
/* 0x00 */ u16 setting;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
struct CsCmdEnvLighting
{
/* 0x00 */ u16 setting;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
}; // size = 0x6
struct CsCmdMusicChange {
/* 0x00 */ u16 sequence;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
struct CsCmdMusicChange
{
/* 0x00 */ u16 sequence;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
}; // size = 0x6
struct CsCmdMusicFade {
/* 0x00 */ u16 type;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
struct CsCmdMusicFade
{
/* 0x00 */ u16 type;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
}; // size = 0x6
struct CsCmdUnknown9 {
/* 0x00 */ u16 unk_00;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
/* 0x06 */ u8 unk_06;
/* 0x07 */ u8 unk_07;
/* 0x08 */ u8 unk_08;
struct CsCmdUnknown9
{
/* 0x00 */ u16 unk_00;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
/* 0x06 */ u8 unk_06;
/* 0x07 */ u8 unk_07;
/* 0x08 */ u8 unk_08;
}; // size = 0xA
struct CsCmdDayTime {
/* 0x00 */ u16 unk_00;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
/* 0x06 */ u8 hour;
/* 0x07 */ u8 minute;
struct CsCmdDayTime
{
/* 0x00 */ u16 unk_00;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
/* 0x06 */ u8 hour;
/* 0x07 */ u8 minute;
}; // size = 0x8
struct CsCmdTextbox {
/* 0x00 */ u16 base;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
/* 0x06 */ u16 type;
/* 0x08 */ u16 textId1;
/* 0x0A */ u16 textId2;
struct CsCmdTextbox
{
/* 0x00 */ u16 base;
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
/* 0x06 */ u16 type;
/* 0x08 */ u16 textId1;
/* 0x0A */ u16 textId2;
}; // size = 0xC
typedef struct {
/* 0x00 */ u16 action; // "dousa"
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
union {
/* 0x06 */ Vec3s rot;
/* 0x06 */ Vec3us urot;
};
/* 0x0C */ Vec3i startPos;
/* 0x18 */ Vec3i endPos;
/* 0x24 */ Vec3i normal;
typedef struct
{
/* 0x00 */ u16 action; // "dousa"
/* 0x02 */ u16 startFrame;
/* 0x04 */ u16 endFrame;
union
{
/* 0x06 */ Vec3s rot;
/* 0x06 */ Vec3us urot;
};
/* 0x0C */ Vec3i startPos;
/* 0x18 */ Vec3i endPos;
/* 0x24 */ Vec3i normal;
} CsCmdActorAction; // size = 0x30
enum CutsceneState {
CS_STATE_IDLE,
CS_STATE_SKIPPABLE_INIT,
CS_STATE_SKIPPABLE_EXEC,
CS_STATE_UNSKIPPABLE_INIT,
CS_STATE_UNSKIPPABLE_EXEC
enum CutsceneState
{
CS_STATE_IDLE,
CS_STATE_SKIPPABLE_INIT,
CS_STATE_SKIPPABLE_EXEC,
CS_STATE_UNSKIPPABLE_INIT,
CS_STATE_UNSKIPPABLE_EXEC
};
enum CutsceneCmd {
CS_CMD_00 = 0x0000,
CS_CMD_CAM_EYE = 0x0001,
CS_CMD_CAM_AT = 0x0002,
CS_CMD_MISC = 0x0003,
CS_CMD_SET_LIGHTING = 0x0004,
CS_CMD_CAM_EYE_REL_TO_PLAYER = 0x0005,
CS_CMD_CAM_AT_REL_TO_PLAYER = 0x0006,
CS_CMD_07 = 0x0007,
CS_CMD_08 = 0x0008,
CS_CMD_09 = 0x0009,
CS_CMD_TEXTBOX = 0x0013,
CS_CMD_SET_PLAYER_ACTION = 0x000A,
CS_CMD_SET_ACTOR_ACTION_1 = 0x000F,
CS_CMD_SET_ACTOR_ACTION_2 = 0x000E,
CS_CMD_SET_ACTOR_ACTION_3 = 0x0019,
CS_CMD_SET_ACTOR_ACTION_4 = 0x001D,
CS_CMD_SET_ACTOR_ACTION_5 = 0x001E,
CS_CMD_SET_ACTOR_ACTION_6 = 0x002C,
CS_CMD_SET_ACTOR_ACTION_7 = 0x001F,
CS_CMD_SET_ACTOR_ACTION_8 = 0x0031,
CS_CMD_SET_ACTOR_ACTION_9 = 0x003E,
CS_CMD_SET_ACTOR_ACTION_10 = 0x008F,
CS_CMD_SCENE_TRANS_FX = 0x002D,
CS_CMD_NOP = 0x000B,
CS_CMD_PLAYBGM = 0x0056,
CS_CMD_STOPBGM = 0x0057,
CS_CMD_FADEBGM = 0x007C,
CS_CMD_SETTIME = 0x008C,
CS_CMD_TERMINATOR = 0x03E8,
CS_CMD_END = 0xFFFF
enum CutsceneCmd
{
CS_CMD_00 = 0x0000,
CS_CMD_CAM_EYE = 0x0001,
CS_CMD_CAM_AT = 0x0002,
CS_CMD_MISC = 0x0003,
CS_CMD_SET_LIGHTING = 0x0004,
CS_CMD_CAM_EYE_REL_TO_PLAYER = 0x0005,
CS_CMD_CAM_AT_REL_TO_PLAYER = 0x0006,
CS_CMD_07 = 0x0007,
CS_CMD_08 = 0x0008,
CS_CMD_09 = 0x0009,
CS_CMD_TEXTBOX = 0x0013,
CS_CMD_SET_PLAYER_ACTION = 0x000A,
CS_CMD_SET_ACTOR_ACTION_1 = 0x000F,
CS_CMD_SET_ACTOR_ACTION_2 = 0x000E,
CS_CMD_SET_ACTOR_ACTION_3 = 0x0019,
CS_CMD_SET_ACTOR_ACTION_4 = 0x001D,
CS_CMD_SET_ACTOR_ACTION_5 = 0x001E,
CS_CMD_SET_ACTOR_ACTION_6 = 0x002C,
CS_CMD_SET_ACTOR_ACTION_7 = 0x001F,
CS_CMD_SET_ACTOR_ACTION_8 = 0x0031,
CS_CMD_SET_ACTOR_ACTION_9 = 0x003E,
CS_CMD_SET_ACTOR_ACTION_10 = 0x008F,
CS_CMD_SCENE_TRANS_FX = 0x002D,
CS_CMD_NOP = 0x000B,
CS_CMD_PLAYBGM = 0x0056,
CS_CMD_STOPBGM = 0x0057,
CS_CMD_FADEBGM = 0x007C,
CS_CMD_SETTIME = 0x008C,
CS_CMD_TERMINATOR = 0x03E8,
CS_CMD_END = 0xFFFF
};
/**
* Special type for blocks of cutscene data, asm-processor checks
* arrays for CutsceneData type and converts floats within the array
* to their IEEE-754 representation. The array must close with };
* arrays for CutsceneData type and converts floats within the array
* to their IEEE-754 representation. The array must close with };
* on its own line.
*
*
* Files that contain this type that are included in other C files
* must include an 'EARLY' qualifier to inform asm-processor that it
* must recursively process that include.
*
*
* Example: #include "file.c" EARLY
*/
typedef union CutsceneData {
s32 i;
f32 f;
s16 s[2];
s8 b[4];
typedef union CutsceneData
{
s32 i;
f32 f;
s16 s[2];
s8 b[4];
} CutsceneData;
#define CS_CMD_CONTINUE 0
#define CS_CMD_STOP -1
// TODO confirm correctness, clarify names
enum CutsceneTerminatorDestination {
/* 0x00 */ INVALID_DESTINATION_0,
/* 0x01 */ CUTSCENE_MAP_GANON_HORSE,
/* 0x02 */ CUTSCENE_MAP_THREE_GODESSES_POST_DEKU_TREE,
/* 0x03 */ GERUDO_VALLEY_DIN,
/* 0x04 */ DEATH_MOUNTAIN_TRAIL_NAYRU,
/* 0x05 */ KOKIRI_FOREST_FARORE,
/* 0x06 */ CUTSCENE_MAP_TRIFORCE_CREATION,
/* 0x07 */ KOKIRI_FOREST_RECEIVE_KOKIRI_EMERALD,
/* 0x08 */ TEMPLE_OF_TIME_AFTER_USE_MS,
/* 0x09 */ GERUDO_VALLEY_DIN_2,
/* 0x0A */ LINKS_HOUSE_INTRO,
/* 0x0B */ KOKIRI_FOREST_INTRO,
/* 0x0C */ DEATH_MOUNTAIN_TRAIL_AFTER_GORON_RUBY,
/* 0x0D */ ZORAS_FOUNTAIN_AFTER_ZORAS_SAPPHIRE,
/* 0x0E */ KOKIRI_FOREST_AFTER_KOKIRI_EMERALD,
/* 0x0F */ TEMPLE_OF_TIME_KOKIRI_EMERALD, //unused
/* 0x10 */ TEMPLE_OF_TIME_GORON_RUBY, //unused
/* 0x11 */ TEMPLE_OF_TIME_ZORAS_SAPPHIRE, //unused
/* 0x12 */ TEMPLE_OF_TIME_AFTER_USE_MS_FIRST,
/* 0x13 */ DEATH_MOUNTAIN_TRAIL_AFTER_INTRO,
/* 0x14 */ INVALID_DESTINATION_14,
/* 0x15 */ LAKE_HYLIA_WATER_RISES,
/* 0x16 */ DESERT_COLOSSUS_REQUIEM,
/* 0x17 */ CUTSCENE_MAP_CURSE_YOU,
/* 0x18 */ JABU_JABU_INTRO,
/* 0x19 */ CHAMBER_OF_SAGES_LIGHT_MEDALLION,
/* 0x1A */ TEMPLE_OF_TIME_KOKIRI_EMERALD_2, //duplicate of 0x000F
/* 0x1B */ TEMPLE_OF_TIME_GORON_RUBY_2, //duplicate of 0x0010
/* 0x1C */ TEMPLE_OF_TIME_ZORAS_SAPPHIRE_2, //duplicate of 0x0011
/* 0x1D */ CHAMBER_OF_SAGES_FOREST_MEDALLION,
/* 0x1E */ CHAMBER_OF_SAGES_FIRE_MEDALLION,
/* 0x1F */ CHAMBER_OF_SAGES_WATER_MEDALLION,
/* 0x20 */ HYRULE_FIELD_FLASHBACK, //lacs part 4
/* 0x21 */ HYRULE_FIELD_AFTER_LAKE_HYLIA_OWL,
/* 0x22 */ CUTSCENE_MAP_GANON_AFTER_USE_MS,
/* 0x23 */ HYRULE_FIELD_INTRO_ZELDA_ESCAPE,
/* 0x24 */ INVALID_DESTINATION_24,
/* 0x25 */ INVALID_DESTINATION_25,
/* 0x26 */ CUTSCENE_MAP_SHEIKAH_LEGEND, //lacs part 2
/* 0x27 */ TEMPLE_OF_TIME_ZELDA_REVEAL, //lacs part 3
/* 0x28 */ TEMPLE_OF_TIME_GET_LIGHT_ARROWS, //lacs part 5
/* 0x29 */ LAKE_HYLIA_AFTER_BLUE_WARP,
/* 0x2A */ KAKARIKO_VILLAGE_DRAIN_WELL,
/* 0x2B */ WINDMILL_AFTER_DRAIN_WELL,
/* 0x2C */ TEMPLE_OF_TIME_AFTER_DOOR_OF_TIME_OPENS,
/* 0x2D */ INVALID_DESTINATION_2D,
/* 0x2E */ TEMPLE_OF_TIME_AFTER_USE_MS_FIRST_2, // duplicate of 0x0012
/* 0x2F */ KAKARIKO_VILLAGE_NOCTURNE_PART_2,
/* 0x30 */ DESERT_COLOSSUS_AFTER_REQUIEM,
/* 0x31 */ TEMPLE_OF_TIME_AFTER_LIGHT_ARROWS,
/* 0x32 */ KAKARIKO_VILLAGE_AFTER_NOCTURNE,
/* 0x33 */ HYRULE_FIELD_IMPA_ESCORT_CS,
/* 0x34 */ TEMPLE_OF_TIME_SONG_OF_TIME,
/* 0x35 */ HYRULE_FIELD_AFTER_SONG_OF_TIME,
/* 0x36 */ GERUDO_VALLEY_CREDITS,
/* 0x37 */ GERUDO_FORTRESS_CREDITS,
/* 0x38 */ KAKARIKO_VILLAGE_CREDITS,
/* 0x39 */ DEATH_MOUNTAIN_TRAIL_CREDITS_1,
/* 0x3A */ GORON_CITY_CREDITS, // unused?
/* 0x3B */ LAKE_HYLIA_CREDITS,
/* 0x3C */ ZORAS_FOUNTAIN_CREDITS, // unused
/* 0x3D */ ZORAS_DOMAIN_CREDITS,
/* 0x3E */ KOKIRI_FOREST_CREDITS_1,
/* 0x3F */ KOKIRI_FOREST_CREDITS_2,
/* 0x40 */ HYRULE_FIELD_CREDITS,
/* 0x41 */ LON_LON_RANCH_CREDITS_1,
/* 0x42 */ KAKARIKO_VILLAGE_AFTER_TRAIL_OWL,
/* 0x43 */ HTRULE_FIELD_UNUSED_ENTRANCE,
/* 0x44 */ CUTSCENE_MAP_FIRE,
/* 0x45 */ KOKIRI_FOREST_POST_FOREST_MEDALLION,
/* 0x46 */ DEATH_MOUNTAIN_TRAIL_CREDITS_2,
/* 0x47 */ TEMPLE_OF_TIME_CREDITS,
/* 0x48 */ ZELDAS_COURTYARD_CREDITS,
/* 0x49 */ LON_LON_RANCH_CREDITS_1_2, // duplicate of 0x0041
/* 0x4A */ LON_LON_RANCH_CREDITS_2,
/* 0x4B */ LON_LON_RANCH_CREDITS_3,
/* 0x4C */ LON_LON_RANCH_CREDITS_4,
/* 0x4D */ LON_LON_RANCH_CREDITS_5,
/* 0x4E */ LON_LON_RANCH_CREDITS_6,
/* 0x4F */ LON_LON_RANCH_NO_CS_1,
/* 0x50 */ LON_LON_RANCH_NO_CS_2,
/* 0x51 */ LON_LON_RANCH_NO_CS_3,
/* 0x52 */ LON_LON_RANCH_NO_CS_4,
/* 0x53 */ LON_LON_RANCH_NO_CS_5,
/* 0x54 */ LON_LON_RANCH_NO_CS_6,
/* 0x55 */ LON_LON_RANCH_NO_CS_7,
/* 0x56 */ LON_LON_RANCH_NO_CS_8,
/* 0x57 */ LON_LON_RANCH_NO_CS_9,
/* 0x58 */ LON_LON_RANCH_NO_CS_10,
/* 0x59 */ LON_LON_RANCH_NO_CS_11,
/* 0x5A */ LON_LON_RANCH_NO_CS_12,
/* 0x5B */ LON_LON_RANCH_NO_CS_13,
/* 0x5C */ LON_LON_RANCH_NO_CS_14,
/* 0x5D */ LON_LON_RANCH_NO_CS_15,
/* 0x5E */ LON_LON_RANCH_NO_CS_EPONAS_SONG,
/* 0x5F */ CONDITIONAL_DESTINATION, // TODO more descriptive name?
/* 0x60 */ DESERT_COLOSSUS_SPIRIT_BLUE_WARP,
/* 0x61 */ GRAVEYARD_AFTER_SHADOW_BLUE_WARP,
/* 0x62 */ DEATH_MOUNTAIN_CRATER_AFTER_FIRE_BLUE_WARP,
/* 0x63 */ SACRED_FOREST_MEADOW_AFTER_FOREST_BLUE_WARP,
/* 0x64 */ KOKIRI_FOREST_AFTER_FOREST_BLUE_WARP,
/* 0x65 */ DESERT_COLOSSUS_AFTER_SILVER_GAUNTLETS,
/* 0x66 */ TEMPLE_OF_TIME_FRONT_OF_PEDESTAL,
/* 0x67 */ HYRULE_FIELD_TITLE_SCREEN,
/* 0x68 */ SPIRIT_TEMPLE_BOSS_TITLE_SCREEN,
/* 0x69 */ GRAVEYARD_SUNS_SONG,
/* 0x6A */ ROYAL_FAMILYS_TOMB_SUNS_SONG,
/* 0x6B */ GANONS_CASTLE_AFTER_FOREST_TRIAL,
/* 0x6C */ GANONS_CASTLE_AFTER_WATER_TRIAL,
/* 0x6D */ GANONS_CASTLE_AFTER_SHADOW_TRIAL,
/* 0x6E */ GANONS_CASTLE_AFTER_FIRE_TRIAL,
/* 0x6F */ GANONS_CASTLE_AFTER_LIGHT_TRIAL,
/* 0x70 */ GANONS_CASTLE_AFTER_SPIRIT_TRIAL,
/* 0x71 */ GANONS_CASTLE_DISPEL_BARRIER_IF_CONDITIONS,
/* 0x72 */ HYRULE_FIELD_INTRO,
/* 0x73 */ HYRULE_FIELD_AFTER_IMPA_ESCORT,
/* 0x74 */ DESERT_COLOSSUS_SPIRIT_BLUE_WARP_2,
/* 0x75 */ HYRULE_FIELD_SKY,
/* 0x76 */ GANON_BATTLE_TOWER_COLLAPSE,
/* 0x77 */ ZELDAS_COURTYARD_RECEIVE_LETTER
enum CutsceneTerminatorDestination
{
/* 0x00 */ INVALID_DESTINATION_0,
/* 0x01 */ CUTSCENE_MAP_GANON_HORSE,
/* 0x02 */ CUTSCENE_MAP_THREE_GODESSES_POST_DEKU_TREE,
/* 0x03 */ GERUDO_VALLEY_DIN,
/* 0x04 */ DEATH_MOUNTAIN_TRAIL_NAYRU,
/* 0x05 */ KOKIRI_FOREST_FARORE,
/* 0x06 */ CUTSCENE_MAP_TRIFORCE_CREATION,
/* 0x07 */ KOKIRI_FOREST_RECEIVE_KOKIRI_EMERALD,
/* 0x08 */ TEMPLE_OF_TIME_AFTER_USE_MS,
/* 0x09 */ GERUDO_VALLEY_DIN_2,
/* 0x0A */ LINKS_HOUSE_INTRO,
/* 0x0B */ KOKIRI_FOREST_INTRO,
/* 0x0C */ DEATH_MOUNTAIN_TRAIL_AFTER_GORON_RUBY,
/* 0x0D */ ZORAS_FOUNTAIN_AFTER_ZORAS_SAPPHIRE,
/* 0x0E */ KOKIRI_FOREST_AFTER_KOKIRI_EMERALD,
/* 0x0F */ TEMPLE_OF_TIME_KOKIRI_EMERALD, // unused
/* 0x10 */ TEMPLE_OF_TIME_GORON_RUBY, // unused
/* 0x11 */ TEMPLE_OF_TIME_ZORAS_SAPPHIRE, // unused
/* 0x12 */ TEMPLE_OF_TIME_AFTER_USE_MS_FIRST,
/* 0x13 */ DEATH_MOUNTAIN_TRAIL_AFTER_INTRO,
/* 0x14 */ INVALID_DESTINATION_14,
/* 0x15 */ LAKE_HYLIA_WATER_RISES,
/* 0x16 */ DESERT_COLOSSUS_REQUIEM,
/* 0x17 */ CUTSCENE_MAP_CURSE_YOU,
/* 0x18 */ JABU_JABU_INTRO,
/* 0x19 */ CHAMBER_OF_SAGES_LIGHT_MEDALLION,
/* 0x1A */ TEMPLE_OF_TIME_KOKIRI_EMERALD_2, // duplicate of 0x000F
/* 0x1B */ TEMPLE_OF_TIME_GORON_RUBY_2, // duplicate of 0x0010
/* 0x1C */ TEMPLE_OF_TIME_ZORAS_SAPPHIRE_2, // duplicate of 0x0011
/* 0x1D */ CHAMBER_OF_SAGES_FOREST_MEDALLION,
/* 0x1E */ CHAMBER_OF_SAGES_FIRE_MEDALLION,
/* 0x1F */ CHAMBER_OF_SAGES_WATER_MEDALLION,
/* 0x20 */ HYRULE_FIELD_FLASHBACK, // lacs part 4
/* 0x21 */ HYRULE_FIELD_AFTER_LAKE_HYLIA_OWL,
/* 0x22 */ CUTSCENE_MAP_GANON_AFTER_USE_MS,
/* 0x23 */ HYRULE_FIELD_INTRO_ZELDA_ESCAPE,
/* 0x24 */ INVALID_DESTINATION_24,
/* 0x25 */ INVALID_DESTINATION_25,
/* 0x26 */ CUTSCENE_MAP_SHEIKAH_LEGEND, // lacs part 2
/* 0x27 */ TEMPLE_OF_TIME_ZELDA_REVEAL, // lacs part 3
/* 0x28 */ TEMPLE_OF_TIME_GET_LIGHT_ARROWS, // lacs part 5
/* 0x29 */ LAKE_HYLIA_AFTER_BLUE_WARP,
/* 0x2A */ KAKARIKO_VILLAGE_DRAIN_WELL,
/* 0x2B */ WINDMILL_AFTER_DRAIN_WELL,
/* 0x2C */ TEMPLE_OF_TIME_AFTER_DOOR_OF_TIME_OPENS,
/* 0x2D */ INVALID_DESTINATION_2D,
/* 0x2E */ TEMPLE_OF_TIME_AFTER_USE_MS_FIRST_2, // duplicate of 0x0012
/* 0x2F */ KAKARIKO_VILLAGE_NOCTURNE_PART_2,
/* 0x30 */ DESERT_COLOSSUS_AFTER_REQUIEM,
/* 0x31 */ TEMPLE_OF_TIME_AFTER_LIGHT_ARROWS,
/* 0x32 */ KAKARIKO_VILLAGE_AFTER_NOCTURNE,
/* 0x33 */ HYRULE_FIELD_IMPA_ESCORT_CS,
/* 0x34 */ TEMPLE_OF_TIME_SONG_OF_TIME,
/* 0x35 */ HYRULE_FIELD_AFTER_SONG_OF_TIME,
/* 0x36 */ GERUDO_VALLEY_CREDITS,
/* 0x37 */ GERUDO_FORTRESS_CREDITS,
/* 0x38 */ KAKARIKO_VILLAGE_CREDITS,
/* 0x39 */ DEATH_MOUNTAIN_TRAIL_CREDITS_1,
/* 0x3A */ GORON_CITY_CREDITS, // unused?
/* 0x3B */ LAKE_HYLIA_CREDITS,
/* 0x3C */ ZORAS_FOUNTAIN_CREDITS, // unused
/* 0x3D */ ZORAS_DOMAIN_CREDITS,
/* 0x3E */ KOKIRI_FOREST_CREDITS_1,
/* 0x3F */ KOKIRI_FOREST_CREDITS_2,
/* 0x40 */ HYRULE_FIELD_CREDITS,
/* 0x41 */ LON_LON_RANCH_CREDITS_1,
/* 0x42 */ KAKARIKO_VILLAGE_AFTER_TRAIL_OWL,
/* 0x43 */ HTRULE_FIELD_UNUSED_ENTRANCE,
/* 0x44 */ CUTSCENE_MAP_FIRE,
/* 0x45 */ KOKIRI_FOREST_POST_FOREST_MEDALLION,
/* 0x46 */ DEATH_MOUNTAIN_TRAIL_CREDITS_2,
/* 0x47 */ TEMPLE_OF_TIME_CREDITS,
/* 0x48 */ ZELDAS_COURTYARD_CREDITS,
/* 0x49 */ LON_LON_RANCH_CREDITS_1_2, // duplicate of 0x0041
/* 0x4A */ LON_LON_RANCH_CREDITS_2,
/* 0x4B */ LON_LON_RANCH_CREDITS_3,
/* 0x4C */ LON_LON_RANCH_CREDITS_4,
/* 0x4D */ LON_LON_RANCH_CREDITS_5,
/* 0x4E */ LON_LON_RANCH_CREDITS_6,
/* 0x4F */ LON_LON_RANCH_NO_CS_1,
/* 0x50 */ LON_LON_RANCH_NO_CS_2,
/* 0x51 */ LON_LON_RANCH_NO_CS_3,
/* 0x52 */ LON_LON_RANCH_NO_CS_4,
/* 0x53 */ LON_LON_RANCH_NO_CS_5,
/* 0x54 */ LON_LON_RANCH_NO_CS_6,
/* 0x55 */ LON_LON_RANCH_NO_CS_7,
/* 0x56 */ LON_LON_RANCH_NO_CS_8,
/* 0x57 */ LON_LON_RANCH_NO_CS_9,
/* 0x58 */ LON_LON_RANCH_NO_CS_10,
/* 0x59 */ LON_LON_RANCH_NO_CS_11,
/* 0x5A */ LON_LON_RANCH_NO_CS_12,
/* 0x5B */ LON_LON_RANCH_NO_CS_13,
/* 0x5C */ LON_LON_RANCH_NO_CS_14,
/* 0x5D */ LON_LON_RANCH_NO_CS_15,
/* 0x5E */ LON_LON_RANCH_NO_CS_EPONAS_SONG,
/* 0x5F */ CONDITIONAL_DESTINATION, // TODO more descriptive name?
/* 0x60 */ DESERT_COLOSSUS_SPIRIT_BLUE_WARP,
/* 0x61 */ GRAVEYARD_AFTER_SHADOW_BLUE_WARP,
/* 0x62 */ DEATH_MOUNTAIN_CRATER_AFTER_FIRE_BLUE_WARP,
/* 0x63 */ SACRED_FOREST_MEADOW_AFTER_FOREST_BLUE_WARP,
/* 0x64 */ KOKIRI_FOREST_AFTER_FOREST_BLUE_WARP,
/* 0x65 */ DESERT_COLOSSUS_AFTER_SILVER_GAUNTLETS,
/* 0x66 */ TEMPLE_OF_TIME_FRONT_OF_PEDESTAL,
/* 0x67 */ HYRULE_FIELD_TITLE_SCREEN,
/* 0x68 */ SPIRIT_TEMPLE_BOSS_TITLE_SCREEN,
/* 0x69 */ GRAVEYARD_SUNS_SONG,
/* 0x6A */ ROYAL_FAMILYS_TOMB_SUNS_SONG,
/* 0x6B */ GANONS_CASTLE_AFTER_FOREST_TRIAL,
/* 0x6C */ GANONS_CASTLE_AFTER_WATER_TRIAL,
/* 0x6D */ GANONS_CASTLE_AFTER_SHADOW_TRIAL,
/* 0x6E */ GANONS_CASTLE_AFTER_FIRE_TRIAL,
/* 0x6F */ GANONS_CASTLE_AFTER_LIGHT_TRIAL,
/* 0x70 */ GANONS_CASTLE_AFTER_SPIRIT_TRIAL,
/* 0x71 */ GANONS_CASTLE_DISPEL_BARRIER_IF_CONDITIONS,
/* 0x72 */ HYRULE_FIELD_INTRO,
/* 0x73 */ HYRULE_FIELD_AFTER_IMPA_ESCORT,
/* 0x74 */ DESERT_COLOSSUS_SPIRIT_BLUE_WARP_2,
/* 0x75 */ HYRULE_FIELD_SKY,
/* 0x76 */ GANON_BATTLE_TOWER_COLLAPSE,
/* 0x77 */ ZELDAS_COURTYARD_RECEIVE_LETTER
};
struct CutsceneContext {
/* 0x00 */ char unk_00[0x4];
/* 0x04 */ void* segment;
/* 0x08 */ u8 state;
/* 0x0C */ f32 unk_0C;
/* 0x10 */ Counter frames;
/* 0x12 */ u16 unk_12;
/* 0x14 */ s32 cutsceneCamera;
/* 0x18 */ Counter unk_18;
/* 0x1A */ u8 unk_1A;
/* 0x1B */ u8 unk_1B;
/* 0x1C */ CutsceneCameraPoint* cameraFocus;
/* 0x20 */ CutsceneCameraPoint* cameraPosition;
/* 0x24 */ CsCmdActorAction* linkAction;
/* 0x28 */ CsCmdActorAction* npcActions[10]; // "npcdemopnt"
}; // size = 0x50
struct CutsceneContext
{
/* 0x00 */ char unk_00[0x4];
/* 0x04 */ void* segment;
/* 0x08 */ u8 state;
/* 0x0C */ f32 unk_0C;
/* 0x10 */ Counter frames;
/* 0x12 */ u16 unk_12;
/* 0x14 */ s32 cutsceneCamera;
/* 0x18 */ Counter unk_18;
/* 0x1A */ u8 unk_1A;
/* 0x1B */ u8 unk_1B;
/* 0x1C */ CutsceneCameraPoint* cameraFocus;
/* 0x20 */ CutsceneCameraPoint* cameraPosition;
/* 0x24 */ CsCmdActorAction* linkAction;
/* 0x28 */ CsCmdActorAction* npcActions[10]; // "npcdemopnt"
}; // size = 0x50
void func_8006450C(struct GlobalContext* globalCtx, CutsceneContext* csCtx);
void func_80064520(struct GlobalContext* globalCtx, CutsceneContext* csCtx);

133
include/z64cutscene_commands.h
View File

@ -11,7 +11,7 @@
* eeeeeeee nnnnnnnn
* size = 0x8
*/
#define CS_BEGIN_CUTSCENE(totalEntries, endFrame) (s32)CMD_W(totalEntries), (s32)CMD_W(endFrame)
#define CS_BEGIN_CUTSCENE(totalEntries, endFrame) (s32) CMD_W(totalEntries), (s32)CMD_W(endFrame)
/**
* ARGS
@ -21,12 +21,11 @@
* size = 0xC
*/
#define CS_CAM_POS_LIST CS_CAM_EYE_LIST
#define CS_CAM_EYE_LIST(startFrame, endFrame) \
CS_CMD_CAM_EYE, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
#define CS_CAM_EYE_LIST(startFrame, endFrame) CS_CMD_CAM_EYE, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
/**
* ARGS
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s16 xPos (x), s16 yPos (y), s16 zPos (z)
* FORMAT
* Capital U is Unused
@ -34,8 +33,7 @@
* size = 0x10
*/
#define CS_CAM_POS CS_CAM_EYE
#define CS_CAM_EYE(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \
(s32)CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
#define CS_CAM_EYE(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) (s32) CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
/**
* ARGS
@ -45,12 +43,11 @@
* size = 0xC
*/
#define CS_CAM_FOCUS_POINT_LIST CS_CAM_AT_LIST
#define CS_CAM_AT_LIST(startFrame, endFrame) \
CS_CMD_CAM_AT, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
#define CS_CAM_AT_LIST(startFrame, endFrame) CS_CMD_CAM_AT, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
/**
* ARGS
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s16 xPos (x), s16 yPos (y), s16 zPos (z)
* FORMAT
* Capital U is Unused
@ -58,8 +55,7 @@
* size = 0x10
*/
#define CS_CAM_FOCUS_POINT CS_CAM_AT
#define CS_CAM_AT(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \
(s32)CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
#define CS_CAM_AT(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) (s32) CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
/**
* ARGS
@ -78,10 +74,9 @@
* uuuussss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU
* size = 0x30
*/
#define CS_MISC(unk, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7, unused8, unused9, unused10) \
(s32)CMD_HH(unk, startFrame), (s32)CMD_HH(endFrame, unused0), \
(s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), \
(s32)CMD_W(unused6), (s32)CMD_W(unused7), (s32)CMD_W(unused8), (s32)CMD_W(unused9), (s32)CMD_W(unused10)
#define CS_MISC(unk, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7, unused8, unused9, unused10) \
(s32) CMD_HH(unk, startFrame), (s32)CMD_HH(endFrame, unused0), (s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), (s32)CMD_W(unused6), (s32)CMD_W(unused7), (s32)CMD_W(unused8), \
(s32)CMD_W(unused9), (s32)CMD_W(unused10)
/**
* ARGS
@ -97,13 +92,11 @@
* s16 setting (m), s16 startFrame (s), s16 endFrame (e)
* FORMAT
* Capital U is Unused
* mmmmssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000
* mmmmssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000
* size = 0x30
*/
#define CS_LIGHTING(setting, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32)CMD_HH(setting, startFrame), (s32)CMD_HH(endFrame, unused0), \
(s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), \
(s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000
#define CS_LIGHTING(setting, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32) CMD_HH(setting, startFrame), (s32)CMD_HH(endFrame, unused0), (s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), (s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000
/**
* ARGS
@ -114,12 +107,11 @@
* size = 0xC
*/
#define CS_CAM_POS_PLAYER_LIST CS_CAM_EYE_REL_TO_PLAYER_LIST
#define CS_CAM_EYE_REL_TO_PLAYER_LIST(startFrame, endFrame) \
CS_CMD_CAM_EYE_REL_TO_PLAYER, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
#define CS_CAM_EYE_REL_TO_PLAYER_LIST(startFrame, endFrame) CS_CMD_CAM_EYE_REL_TO_PLAYER, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
/**
* ARGS
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s16 xPos (x), s16 yPos (y), s16 zPos (z)
* FORMAT
* Capital U is Unused
@ -127,8 +119,7 @@
* size = 0x10
*/
#define CS_CAM_POS_PLAYER CS_CAM_EYE_REL_TO_PLAYER
#define CS_CAM_EYE_REL_TO_PLAYER(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \
(s32)CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
#define CS_CAM_EYE_REL_TO_PLAYER(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) (s32) CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
/**
* ARGS
@ -139,11 +130,10 @@
* size = 0xC
*/
#define CS_CAM_FOCUS_POINT_PLAYER_LIST CS_CAM_AT_REL_TO_PLAYER_LIST
#define CS_CAM_AT_REL_TO_PLAYER_LIST(startFrame, endFrame) \
CS_CMD_CAM_AT_REL_TO_PLAYER, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
#define CS_CAM_AT_REL_TO_PLAYER_LIST(startFrame, endFrame) CS_CMD_CAM_AT_REL_TO_PLAYER, (s32)CMD_HH(0x0001, startFrame), (s32)CMD_HH(endFrame, 0x0000)
/**
* ARGS
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s16 xPos (x), s16 yPos (y), s16 zPos (z)
* FORMAT
* Capital U is Unused
@ -151,8 +141,7 @@
* size = 0x10
*/
#define CS_CAM_FOCUS_POINT_PLAYER CS_CAM_AT_REL_TO_PLAYER
#define CS_CAM_AT_REL_TO_PLAYER(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \
(s32)CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
#define CS_CAM_AT_REL_TO_PLAYER(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) (s32) CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
/**
* ARGS
@ -162,20 +151,18 @@
* 00000007 uuuussss eeeeUUUU
* size = 0xC
*/
#define CS_CMD_07_LIST(unk, startFrame, endFrame, unused) \
CS_CMD_07, (s32)CMD_HH(unk, startFrame), (s32)CMD_HH(endFrame, unused)
#define CS_CMD_07_LIST(unk, startFrame, endFrame, unused) CS_CMD_07, (s32)CMD_HH(unk, startFrame), (s32)CMD_HH(endFrame, unused)
/**
* ARGS
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s16 xPos (x), s16 yPos (y), s16 zPos (z)
* FORMAT
* Capital U is Unused
* ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU
* size = 0x10
*/
#define CS_CMD_07(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \
(s32)CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
#define CS_CMD_07(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) (s32) CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
/**
* ARGS
@ -185,20 +172,18 @@
* 00000008 uuuussss eeeeUUUU
* size = 0xC
*/
#define CS_CMD_08_LIST(unk, startFrame, endFrame, unused) \
CS_CMD_08, (s32)CMD_HH(unk, startFrame), (s32)CMD_HH(endFrame, unused)
#define CS_CMD_08_LIST(unk, startFrame, endFrame, unused) CS_CMD_08, (s32)CMD_HH(unk, startFrame), (s32)CMD_HH(endFrame, unused)
/**
* ARGS
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a),
* s16 xPos (x), s16 yPos (y), s16 zPos (z)
* FORMAT
* Capital U is Unused
* ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU
* size = 0x10
*/
#define CS_CMD_08(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \
(s32)CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
#define CS_CMD_08(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) (s32) CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), (s32)CMD_HH(xPos, yPos), (s32)CMD_HH(zPos, unused)
/**
* ARGS
@ -217,8 +202,7 @@
* uuuussss eeeevvww xxUUUUUU
* size = 0xC
*/
#define CS_CMD_09(unk, startFrame, endFrame, unk2, unk3, unk4, unused0, unused1) \
(s32)CMD_HH(unk, startFrame), (s32)CMD_HBB(endFrame, unk2, unk3), (s32)CMD_BBH(unk4, unused0, unused1)
#define CS_CMD_09(unk, startFrame, endFrame, unk2, unk3, unk4, unused0, unused1) (s32) CMD_HH(unk, startFrame), (s32)CMD_HBB(endFrame, unk2, unk3), (s32)CMD_BBH(unk4, unused0, unused1)
/**
* ARGS
@ -227,19 +211,18 @@
* cccccccc eeeeeeee
* size = 0x8
*/
#define CS_UNK_DATA_LIST(cmdType, entries) (s32)CMD_W(cmdType), (s32)CMD_W(entries)
#define CS_UNK_DATA_LIST(cmdType, entries) (s32) CMD_W(cmdType), (s32)CMD_W(entries)
/**
* ARGS
* s32 unk1 (a), s32 unk2 (b), s32 unk3 (c), s32 unk4 (d), s32 unk5 (e), s32 unk6 (f),
* s32 unk1 (a), s32 unk2 (b), s32 unk3 (c), s32 unk4 (d), s32 unk5 (e), s32 unk6 (f),
* s32 unk7 (g), s32 unk8 (h), s32 unk9 (i), s32 unk10 (j), s32 unk11 (k), s32 unk12 (l)
* FORMAT
* aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh iiiiiiii jjjjjjjj kkkkkkkk llllllll
* size = 0x30
*/
#define CS_UNK_DATA(unk1, unk2, unk3, unk4, unk5, unk6, unk7, unk8, unk9, unk10, unk11, unk12) \
(s32)CMD_W(unk1), (s32)CMD_W(unk2), (s32)CMD_W(unk3), (s32)CMD_W(unk4), (s32)CMD_W(unk5), (s32)CMD_W(unk6), \
(s32)CMD_W(unk7), (s32)CMD_W(unk8), (s32)CMD_W(unk9), (s32)CMD_W(unk10), (s32)CMD_W(unk11), (s32)CMD_W(unk12)
#define CS_UNK_DATA(unk1, unk2, unk3, unk4, unk5, unk6, unk7, unk8, unk9, unk10, unk11, unk12) \
(s32) CMD_W(unk1), (s32)CMD_W(unk2), (s32)CMD_W(unk3), (s32)CMD_W(unk4), (s32)CMD_W(unk5), (s32)CMD_W(unk6), (s32)CMD_W(unk7), (s32)CMD_W(unk8), (s32)CMD_W(unk9), (s32)CMD_W(unk10), (s32)CMD_W(unk11), (s32)CMD_W(unk12)
/**
* ARGS
@ -248,7 +231,7 @@
* cccccccc eeeeeeee
* size = 0x8
*/
#define CS_NPC_ACTION_LIST(cmdType, entries) (s32)CMD_W(cmdType), (s32)CMD_W(entries)
#define CS_NPC_ACTION_LIST(cmdType, entries) (s32) CMD_W(cmdType), (s32)CMD_W(entries)
/**
* ARGS
@ -261,11 +244,8 @@
* aaaassss eeeeuuuu vvvvwwww iiiiiiii jjjjjjjj kkkkkkkk llllllll mmmmmmmm nnnnnnnn xxxxxxxx yyyyyyyy zzzzzzzz
* size = 0x30
*/
#define CS_NPC_ACTION(npcAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) \
(s32)(CMD_HH(npcAction, startFrame)), (s32)CMD_HH(endFrame, rotX), (s32)CMD_HH(rotY, rotZ), \
(s32)CMD_W(startX), (s32)CMD_W(startY), (s32)CMD_W(startZ), \
(s32)CMD_W(endX), (s32)CMD_W(endY), (s32)CMD_W(endZ), \
CMD_F(normX), CMD_F(normY), CMD_F(normZ)
#define CS_NPC_ACTION(npcAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) \
(s32)(CMD_HH(npcAction, startFrame)), (s32)CMD_HH(endFrame, rotX), (s32)CMD_HH(rotY, rotZ), (s32)CMD_W(startX), (s32)CMD_W(startY), (s32)CMD_W(startZ), (s32)CMD_W(endX), (s32)CMD_W(endY), (s32)CMD_W(endZ), CMD_F(normX), CMD_F(normY), CMD_F(normZ)
/**
* ARGS
@ -287,8 +267,8 @@
* aaaassss eeeeuuuu vvvvwwww iiiiiiii jjjjjjjj kkkkkkkk llllllll mmmmmmmm nnnnnnnn xxxxxxxx yyyyyyyy zzzzzzzz
* size = 0x30
*/
#define CS_PLAYER_ACTION(linkAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) \
CS_NPC_ACTION(linkAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ)
#define CS_PLAYER_ACTION(linkAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) \
CS_NPC_ACTION(linkAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ)
/**
* ARGS
@ -301,14 +281,13 @@
/**
* ARGS
* s16 messageId (i), s16 startFrame (s), s16 endFrame (e), s16 type (o),
* s16 messageId (i), s16 startFrame (s), s16 endFrame (e), s16 type (o),
* s16 topOptionBranch (y), s16 bottomOptionBranch (n)
* FORMAT
* iiiissss eeeeoooo yyyynnnn
* size = 0xC
*/
#define CS_TEXT_DISPLAY_TEXTBOX(messageId, startFrame, endFrame, type, topOptionBranch, bottomOptionBranch) \
(s32)CMD_HH(messageId, startFrame), (s32)CMD_HH(endFrame, type), (s32)CMD_HH(topOptionBranch, bottomOptionBranch)
#define CS_TEXT_DISPLAY_TEXTBOX(messageId, startFrame, endFrame, type, topOptionBranch, bottomOptionBranch) (s32) CMD_HH(messageId, startFrame), (s32)CMD_HH(endFrame, type), (s32)CMD_HH(topOptionBranch, bottomOptionBranch)
/**
* ARGS
@ -317,8 +296,7 @@
* FFFFssss eeeeFFFF FFFFFFFF
* size = 0xC
*/
#define CS_TEXT_NONE(startFrame, endFrame) \
CS_TEXT_DISPLAY_TEXTBOX(0xFFFF, startFrame, endFrame, 0xFFFF, 0xFFFF, 0xFFFF)
#define CS_TEXT_NONE(startFrame, endFrame) CS_TEXT_DISPLAY_TEXTBOX(0xFFFF, startFrame, endFrame, 0xFFFF, 0xFFFF, 0xFFFF)
/**
* ARGS
@ -327,8 +305,7 @@
* oooossss eeee0002 iiiiFFFF
* size = 0xC
*/
#define CS_TEXT_LEARN_SONG(ocarinaSongAction, startFrame, endFrame, messageId) \
CS_TEXT_DISPLAY_TEXTBOX(ocarinaSongAction, startFrame, endFrame, 0x0002, messageId, 0xFFFF)
#define CS_TEXT_LEARN_SONG(ocarinaSongAction, startFrame, endFrame, messageId) CS_TEXT_DISPLAY_TEXTBOX(ocarinaSongAction, startFrame, endFrame, 0x0002, messageId, 0xFFFF)
/**
* ARGS
@ -338,8 +315,7 @@
* 0000002D 00000001 ttttssss eeeeUUUU
* size = 0x10
*/
#define CS_SCENE_TRANS_FX(transitionType, startFrame, endFrame) \
CS_CMD_SCENE_TRANS_FX, 0x00000001, (s32)CMD_HH(transitionType, startFrame), (s32)CMD_HH(endFrame, endFrame)
#define CS_SCENE_TRANS_FX(transitionType, startFrame, endFrame) CS_CMD_SCENE_TRANS_FX, 0x00000001, (s32)CMD_HH(transitionType, startFrame), (s32)CMD_HH(endFrame, endFrame)
/**
* ARGS
@ -358,10 +334,9 @@
* qqqqssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000
* size = 0x30
*/
#define CS_PLAY_BGM(sequence, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32)CMD_HH(sequence, startFrame), (s32)CMD_HH(endFrame, unused0), \
(s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), \
(s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000
#define CS_PLAY_BGM(sequence, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32) CMD_HH(sequence, startFrame), (s32)CMD_HH(endFrame, unused0), (s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), (s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, \
0x00000000
/**
* ARGS
@ -380,10 +355,9 @@
* uuqqssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000
* size = 0x30
*/
#define CS_STOP_BGM(sequence, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32)CMD_HH(sequence, startFrame), (s32)CMD_HH(endFrame, unused0), \
(s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), \
(s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000
#define CS_STOP_BGM(sequence, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32) CMD_HH(sequence, startFrame), (s32)CMD_HH(endFrame, unused0), (s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), (s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, \
0x00000000
/**
* ARGS
@ -402,10 +376,9 @@
* ttttssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000
* size = 0x30
*/
#define CS_FADE_BGM(fadeType, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32)CMD_HH(fadeType, startFrame), (s32)CMD_HH(endFrame, unused0), \
(s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), \
(s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000
#define CS_FADE_BGM(fadeType, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \
(s32) CMD_HH(fadeType, startFrame), (s32)CMD_HH(endFrame, unused0), (s32)CMD_W(unused1), (s32)CMD_W(unused2), (s32)CMD_W(unused3), (s32)CMD_W(unused4), (s32)CMD_W(unused5), (s32)CMD_W(unused6), (s32)CMD_W(unused7), 0x00000000, 0x00000000, \
0x00000000
/**
* ARGS
@ -424,10 +397,7 @@
* uuuussss eeeehhmm UUUUUUUU
* size = 0xC
*/
#define CS_TIME(unk, startFrame, endFrame, hour, min, unused) \
(s32)CMD_HH(unk, startFrame), \
CMD_HBB(endFrame, hour, min), \
(s32)CMD_W(unused)
#define CS_TIME(unk, startFrame, endFrame, hour, min, unused) (s32) CMD_HH(unk, startFrame), CMD_HBB(endFrame, hour, min), (s32)CMD_W(unused)
/**
* ARGS
@ -437,8 +407,7 @@
* 000003E8 00000001 ddddssss eeeeUUUU
* size = 0x10
*/
#define CS_TERMINATOR(dest, startFrame, endFrame) \
CS_CMD_TERMINATOR, 0x00000001, (s32)CMD_HH(dest, startFrame), (s32)CMD_HH(endFrame, endFrame)
#define CS_TERMINATOR(dest, startFrame, endFrame) CS_CMD_TERMINATOR, 0x00000001, (s32)CMD_HH(dest, startFrame), (s32)CMD_HH(endFrame, endFrame)
/**
* Marks the end of a cutscene

Some files were not shown because too many files have changed in this diff Show More