mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-14 11:54:39 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into doc_pause_menu

Browse source
This commit is contained in:
Dragorn421 2022-09-04 16:03:05 +02:00
commit c7ba9adec2
No known key found for this signature in database
GPG key ID: 32B53D2D16FC4118
61 changed files with 1227 additions and 934 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/code/__osMalloc.c
View file

@ -163,7 +163,7 @@ void __osMallocCleanup(Arena* arena) {
bzero(arena, sizeof(*arena));
}
u8 __osMallocIsInitalized(Arena* arena) {
u8 __osMallocIsInitialized(Arena* arena) {
return arena->isInit;
}
@ -682,8 +682,8 @@ void __osDisplayArena(Arena* arena) {
ArenaNode* iter;
ArenaNode* next;
if (!__osMallocIsInitalized(arena)) {
osSyncPrintf("アリーナは初期化されていません\n"); // "Arena is not initalized"
if (!__osMallocIsInitialized(arena)) {
osSyncPrintf("アリーナは初期化されていません\n"); // "Arena is not initialized"
return;
}
@ -746,7 +746,7 @@ void ArenaImpl_FaultClient(Arena* arena) {
ArenaNode* next;
FaultDrawer_Printf("ARENA INFO (0x%08x)\n", arena);
if (!__osMallocIsInitalized(arena)) {
if (!__osMallocIsInitialized(arena)) {
FaultDrawer_Printf("Arena is uninitalized\n", arena);
return;
}

2
src/code/audio_heap.c
View file

@ -1059,7 +1059,7 @@ void AudioHeap_Init(void) {
AudioHeap_InitSampleCaches(spec->persistentSampleCacheSize, spec->temporarySampleCacheSize);
AudioLoad_InitSampleDmaBuffers(gAudioContext.numNotes);
// Initalize Loads
// Initialize Loads
gAudioContext.preloadSampleStackTop = 0;
AudioLoad_InitSlowLoads();
AudioLoad_InitScriptLoads();

4
src/code/audio_load.c
View file

@ -70,7 +70,7 @@ s32 sAudioLoadPad2[4]; // double file padding?
DmaHandler sDmaHandler = osEPiStartDma;
void* sUnusedHandler = NULL;
s32 gAudioContextInitalized = false;
s32 gAudioContextInitialized = false;
void AudioLoad_DecreaseSampleDmaTtls(void) {
u32 i;
@ -1235,7 +1235,7 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
}
AudioHeap_InitPool(&gAudioContext.permanentPool, ramAddr, gAudioHeapInitSizes.permanentPoolSize);
gAudioContextInitalized = true;
gAudioContextInitialized = true;
osSendMesg(gAudioContext.taskStartQueueP, (OSMesg)gAudioContext.totalTaskCount, OS_MESG_NOBLOCK);
}

2
src/code/audio_synthesis.c
View file

@ -1266,7 +1266,7 @@ Acmd* AudioSynth_LoadWaveSamples(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
}
/**
* The Haas Effect gives directionality to sound by appling a small (< 35ms) delay to either the left or right channel.
* The Haas Effect gives directionality to sound by applying a small (< 35ms) delay to either the left or right channel.
* The delay is small enough that the sound is still perceived as one sound, but the channel that is not delayed will
* reach our ear first and give a sense of directionality. The sound is directed towards the opposite side of the delay.
*/

2
src/code/code_800E4FE0.c
View file

@ -573,7 +573,7 @@ s32 func_800E5F88(s32 resetPreloadID) {
void Audio_PreNMIInternal(void) {
gAudioContext.resetTimer = 1;
if (gAudioContextInitalized) {
if (gAudioContextInitialized) {
func_800E5F88(0);
gAudioContext.resetStatus = 0;
}

13
src/code/code_800EC960.c
View file

@ -1267,7 +1267,8 @@ OcarinaNote sScarecrowsLongSongSecondNote;
u8 sAudioHasMalonBgm;
f32 sAudioMalonBgmDist;
void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode);
void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 gameRequest);
void Audio_StepFreqLerp(FreqLerp* lerp);
void func_800F56A8(void);
void Audio_PlayNatureAmbienceSequence(u8 natureAmbienceId);
@ -1292,11 +1293,11 @@ void AudioOcarina_SetCustomButtonMapping(u8 useCustom) {
}
void AudioOcarina_ReadControllerInput(void) {
Input inputs[4];
Input inputs[MAXCONTROLLERS];
Input* input = &inputs[0];
u32 ocarinaInputButtonPrev = sOcarinaInputButtonCur;
PadMgr_RequestPadData(&gPadMgr, inputs, 0);
PadMgr_RequestPadData(&gPadMgr, inputs, false);
sOcarinaInputButtonCur = input->cur.button;
sOcarinaInputButtonPrev = ocarinaInputButtonPrev;
sOcarinaInputStickAdj.x = input->rel.stick_x;
@ -2371,10 +2372,10 @@ u8 sAudioNatureFailed = false;
u8 sPeakNumNotes = 0;
void AudioDebug_SetInput(void) {
Input inputs[4];
Input inputs[MAXCONTROLLERS];
u32 btn;
PadMgr_RequestPadData(&gPadMgr, inputs, 0);
PadMgr_RequestPadData(&gPadMgr, inputs, false);
btn = inputs[3].cur.button;
sDebugPadHold = btn & 0xFFFF;
sDebugPadPress = (btn ^ sDebugPadBtnLast) & btn;
@ -4854,7 +4855,7 @@ void Audio_SetSequenceMode(u8 seqMode) {
sPrevSeqMode = seqMode + 0x80;
}
} else {
// Hyrule Field will play slightly different bgm music depending on whether player is standing
// Hyrule Field will play slightly different background music depending on whether player is standing
// still or moving. This is the logic to determine the transition between those two states
if (seqMode == SEQ_MODE_DEFAULT) {
if (sPrevSeqMode == SEQ_MODE_STILL) {

208
src/code/db_camera.c
View file

@ -1,6 +1,8 @@
#include "ultra64.h"
#include "global.h"
#define DBCAM_CONTROLLER_PORT 2
static PlayState* sPlay;
// TODO: cleanup these arrays and UB access
@ -346,7 +348,7 @@ s32 func_800B4370(DbCamera* dbCamera, s16 idx, Camera* cam) {
void func_800B44E0(DbCamera* dbCamera, Camera* cam) {
s32 i;
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CRIGHT)) {
sDbCamAnim.keyframe = 0;
sDbCamAnim.unk_0A = 1;
sDbCamAnim.curFrame = 0.0f;
@ -597,7 +599,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
sp80 = &dbCamera->eye;
sp7C = &dbCamera->at;
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_Z)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_Z)) {
dbCamera->unk_00++;
dbCamera->unk_00 %= 3;
dbCamera->unk_38 = 1;
@ -688,7 +690,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
dbCamera->unk_3C = D_80161140;
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_B | BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_B | BTN_L)) {
sp104.r += temp_f2;
if (sp104.r > 30000.0f) {
@ -702,7 +704,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
dbCamera->unk_40 = 7;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_B)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_B)) {
spFC = sp104;
spFC.r = temp_f2;
if (!D_80161144) {
@ -719,7 +721,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 0xB;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_A | BTN_L)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_A | BTN_L)) {
sp104.r -= temp_f2;
if (sp104.r < 10.0f) {
sp104.r = 10.0f;
@ -730,7 +732,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 8;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_A)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_A)) {
spFC = sp104;
spFC.r = -temp_f2;
if (!D_80161144) {
@ -752,7 +754,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_40 = -1;
}
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DDOWN | BTN_L)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DDOWN | BTN_L)) {
spFC = sp104;
spFC.r = temp_f2;
spFC.pitch = 0;
@ -770,7 +772,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 1;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DUP | BTN_L)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DUP | BTN_L)) {
spFC = sp104;
spFC.r = -temp_f2;
spFC.pitch = 0;
@ -787,7 +789,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 2;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DUP)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DUP)) {
spFC = sp104;
spFC.r = temp_f2;
spFC.pitch = 0x3FFF;
@ -803,7 +805,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 3;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DDOWN)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DDOWN)) {
spFC = sp104;
spFC.r = temp_f2;
spFC.pitch = -0x3FFF;
@ -819,8 +821,8 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 4;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, (BTN_DRIGHT | BTN_L)) ||
CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DRIGHT)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, (BTN_DRIGHT | BTN_L)) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DRIGHT)) {
spFC = sp104;
spFC.r = temp_f2;
spFC.pitch = 0;
@ -837,8 +839,8 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 5;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, (BTN_DLEFT | BTN_L)) ||
CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DLEFT)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, (BTN_DLEFT | BTN_L)) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DLEFT)) {
spFC = sp104;
spFC.r = temp_f2;
spFC.pitch = 0;
@ -855,7 +857,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 6;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_B | BTN_L)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_B | BTN_L)) {
sp104.r = sp104.r + temp_f2;
if (sp104.r > 30000.0f) {
sp104.r = 30000.0f;
@ -866,7 +868,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 7;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_B)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_B)) {
spFC = sp104;
spFC.r = temp_f2;
if (!D_80161144) {
@ -883,7 +885,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 0xB;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_A | BTN_L)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_A | BTN_L)) {
sp104.r -= temp_f2;
if (sp104.r < 10.0f) {
@ -895,7 +897,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_44 = 0;
}
dbCamera->unk_40 = 8;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_A)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_A)) {
spFC = sp104;
spFC.r = -temp_f2;
if (!D_80161144) {
@ -917,7 +919,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->unk_40 = -1;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_R)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_R)) {
if (dbCamera->unk_00 == 0) {
dbCamera->sub.unk_104A = cam->inputDir;
*sp7C = cam->at;
@ -932,13 +934,13 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
func_800B41DC(dbCamera, dbCamera->sub.unkIdx, cam);
} else {
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_R) &&
CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_R) &&
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
Audio_PlaySfxGeneral(NA_SE_SY_CANCEL, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.nPoints = dbCamera->sub.unkIdx + 1;
func_800B4088(dbCamera, cam);
} else if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_R)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_R)) {
if (dbCamera->sub.unkIdx == 0x80) {
Audio_PlaySfxGeneral(NA_SE_SY_ERROR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -955,8 +957,8 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
}
} else {
temp_f0_5 = sPlay->state.input[2].rel.stick_y;
temp_f2_2 = sPlay->state.input[2].rel.stick_x;
temp_f0_5 = sPlay->state.input[DBCAM_CONTROLLER_PORT].rel.stick_y;
temp_f2_2 = sPlay->state.input[DBCAM_CONTROLLER_PORT].rel.stick_x;
pitch = CAM_DEG_TO_BINANG((SQ(temp_f0_5) / 600.0f) * 0.8f);
yaw = CAM_DEG_TO_BINANG((SQ(temp_f2_2) / 600.0f) * 0.8f);
if (!D_80161144) {
@ -977,7 +979,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
DbCamera_CalcUpFromPitchYawRoll(&dbCamera->unk_1C, spF4.pitch, spF4.yaw,
CAM_DEG_TO_BINANG(dbCamera->rollDegrees));
if (dbCamera->unk_00 == 1) {
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_CRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_CRIGHT)) {
cam->inputDir = dbCamera->sub.unk_104A;
new_var2 = OLib_Vec3fDist(&cam->at, &cam->eye);
cam->at = *sp7C;
@ -991,12 +993,12 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
if (dbCamera->unk_00 == 1) {
OREG(0) = 8;
func_8006376C(0xC, 5, 0, D_8012CEF4);
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_CRIGHT) &&
!CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_CRIGHT) &&
!CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
func_800B44E0(dbCamera, cam);
} else {
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CRIGHT) &&
CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CRIGHT) &&
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
Audio_PlaySfxGeneral(NA_SE_SY_GET_RUPY, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
osSyncPrintf("@@@\n@@@\n@@@/* *** spline point data ** start here *** */\n@@@\n");
@ -1006,14 +1008,14 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
osSyncPrintf("@@@static short nFrames = %d;\n@@@\n", dbCamera->sub.nFrames);
osSyncPrintf("@@@static short Mode = %d;\n@@@\n", dbCamera->sub.mode);
osSyncPrintf("@@@\n@@@\n@@@/* *** spline point data ** finish! *** */\n@@@\n");
} else if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CLEFT)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CLEFT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.unk_08 = (dbCamera->sub.unk_08 + 1) % 3;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CUP) &&
CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CUP) &&
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
Audio_PlaySfxGeneral(NA_SE_IT_SWORD_IMPACT, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.unkIdx > 0) {
@ -1022,7 +1024,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->sub.unkIdx = dbCamera->sub.nPoints - 1;
}
} else {
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CUP)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CUP)) {
Audio_PlaySfxGeneral(NA_SE_IT_SWORD_IMPACT, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.unkIdx > 0) {
@ -1043,8 +1045,8 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L) &&
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CDOWN)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L) &&
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CDOWN)) {
Audio_PlaySfxGeneral(NA_SE_IT_SWORD_IMPACT, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.unkIdx < (dbCamera->sub.nPoints - 1)) {
@ -1053,7 +1055,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->sub.unkIdx = 0;
}
} else {
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CDOWN)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CDOWN)) {
Audio_PlaySfxGeneral(NA_SE_IT_SWORD_IMPACT, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.unkIdx < (dbCamera->sub.nPoints - 1)) {
@ -1123,7 +1125,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
break;
case 1:
dbCamera->unk_3C = true;
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DUP)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DUP)) {
Audio_PlaySfxGeneral(NA_SE_SY_ATTENTION_ON, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.unk_0A == 0) {
@ -1132,7 +1134,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->sub.unk_0A--;
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DDOWN)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DDOWN)) {
Audio_PlaySfxGeneral(NA_SE_SY_ATTENTION_ON, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.unk_0A == 5) {
@ -1141,12 +1143,12 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->sub.unk_0A++;
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DLEFT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DLEFT)) {
Audio_PlaySfxGeneral(NA_SE_SY_ATTENTION_ON, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
switch (dbCamera->sub.unk_0A) {
case 1:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].nextPointFrame -= 5;
} else {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].nextPointFrame--;
@ -1178,7 +1180,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->sub.unk_0C = false;
break;
case 2:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].cameraRoll -= 5;
dbCamera->roll = dbCamera->sub.lookAt[dbCamera->sub.unkIdx].cameraRoll;
} else {
@ -1190,7 +1192,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DLEFT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DLEFT)) {
if ((D_8012D10C++ % 5) == 0) {
Audio_PlaySfxGeneral(NA_SE_SY_ATTENTION_ON, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -1198,7 +1200,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
switch (dbCamera->sub.unk_0A) {
case 0:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].viewAngle -= 1.0f;
dbCamera->fov = dbCamera->sub.lookAt[dbCamera->sub.unkIdx].viewAngle;
} else {
@ -1207,7 +1209,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
break;
case 5:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.nFrames -= 10;
} else {
dbCamera->sub.nFrames--;
@ -1229,13 +1231,13 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DRIGHT)) {
Audio_PlaySfxGeneral(NA_SE_SY_ATTENTION_ON, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
switch (dbCamera->sub.unk_0A) {
case 1:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].nextPointFrame += 5;
} else {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].nextPointFrame++;
@ -1267,7 +1269,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->sub.unk_0C = true;
break;
case 2:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].cameraRoll += 5;
dbCamera->roll = dbCamera->sub.lookAt[dbCamera->sub.unkIdx].cameraRoll;
} else {
@ -1278,7 +1280,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
break;
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_DRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_DRIGHT)) {
if ((D_8012D10C++ % 5) == 0) {
Audio_PlaySfxGeneral(NA_SE_SY_ATTENTION_ON, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -1286,7 +1288,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
switch (dbCamera->sub.unk_0A) {
case 0:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.lookAt[dbCamera->sub.unkIdx].viewAngle += 1.0f;
dbCamera->fov = dbCamera->sub.lookAt[dbCamera->sub.unkIdx].viewAngle;
} else {
@ -1295,7 +1297,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
}
break;
case 5:
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
dbCamera->sub.nFrames += 10;
} else {
dbCamera->sub.nFrames++;
@ -1432,7 +1434,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
dbCamera->roll = 0;
dbCamera->fov = 60.0f;
dbCamera->rollDegrees = dbCamera->roll * 1.40625f;
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CLEFT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CLEFT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->unk_78 = (dbCamera->unk_78 + 1) % 3;
@ -1603,7 +1605,7 @@ s32 DbCamera_LoadCallback(char* c) {
}
}
if (!Mempak_Read(2, *c, sDbCameraCuts, 0, sizeof(sDbCameraCuts))) {
if (!Mempak_Read(DBCAM_CONTROLLER_PORT, *c, sDbCameraCuts, 0, sizeof(sDbCameraCuts))) {
return false;
}
@ -1618,7 +1620,7 @@ s32 DbCamera_LoadCallback(char* c) {
osSyncPrintf("%s: %d: デバッグカメラ メモリ確保失敗！！\n", "../db_camera.c", 2847);
return false;
}
if (!Mempak_Read(2, *c, sDbCameraCuts[i].lookAt, off, ALIGN32(size))) {
if (!Mempak_Read(DBCAM_CONTROLLER_PORT, *c, sDbCameraCuts[i].lookAt, off, ALIGN32(size))) {
return false;
}
off += ALIGN32(size);
@ -1629,7 +1631,7 @@ s32 DbCamera_LoadCallback(char* c) {
osSyncPrintf("%s: %d: デバッグカメラ メモリ確保失敗！！\n", "../db_camera.c", 2858);
return false;
}
if (!Mempak_Read(2, *c, sDbCameraCuts[i].position, off, ALIGN32(size))) {
if (!Mempak_Read(DBCAM_CONTROLLER_PORT, *c, sDbCameraCuts[i].position, off, ALIGN32(size))) {
return false;
}
off += ALIGN32(size);
@ -1649,16 +1651,16 @@ s32 DbCamera_SaveCallback(char* c) {
s32 size;
s32 i;
ret = Mempak_GetFileSize(2, *c);
freeSize = Mempak_GetFreeBytes(2);
ret = Mempak_GetFileSize(DBCAM_CONTROLLER_PORT, *c);
freeSize = Mempak_GetFreeBytes(DBCAM_CONTROLLER_PORT);
if ((u32)sAllocSize < (freeSize + ret)) {
if (!Mempak_Alloc(2, c, sAllocSize)) {
if (!Mempak_Alloc(DBCAM_CONTROLLER_PORT, c, sAllocSize)) {
return false;
}
if (!Mempak_Write(2, *c, sDbCameraCuts, 0, sizeof(sDbCameraCuts))) {
Mempak_DeleteFile(2, *c);
if (!Mempak_Write(DBCAM_CONTROLLER_PORT, *c, sDbCameraCuts, 0, sizeof(sDbCameraCuts))) {
Mempak_DeleteFile(DBCAM_CONTROLLER_PORT, *c);
return false;
}
@ -1667,13 +1669,13 @@ s32 DbCamera_SaveCallback(char* c) {
if (sDbCameraCuts[i].letter != '?') {
size = sDbCameraCuts[i].nPoints * sizeof(CutsceneCameraPoint);
ret = Mempak_Write(2, *c, sDbCameraCuts[i].lookAt, off, ALIGN32(size));
ret = Mempak_Write(DBCAM_CONTROLLER_PORT, *c, sDbCameraCuts[i].lookAt, off, ALIGN32(size));
if (!ret) {
break;
}
off += ALIGN32(size);
ret = Mempak_Write(2, *c, sDbCameraCuts[i].position, off, ALIGN32(size));
ret = Mempak_Write(DBCAM_CONTROLLER_PORT, *c, sDbCameraCuts[i].position, off, ALIGN32(size));
if (!ret) {
break;
}
@ -1686,7 +1688,7 @@ s32 DbCamera_SaveCallback(char* c) {
if (ret) {
return *c;
} else {
Mempak_DeleteFile(2, *c);
Mempak_DeleteFile(DBCAM_CONTROLLER_PORT, *c);
return false;
}
}
@ -1695,7 +1697,7 @@ s32 DbCamera_SaveCallback(char* c) {
}
s32 DbCamera_ClearCallback(char* c) {
return Mempak_DeleteFile(2, *c);
return Mempak_DeleteFile(DBCAM_CONTROLLER_PORT, *c);
}
void DbCamera_DrawSlotLetters(char* str, s16 y, s16 x, s32 colorIndex) {
@ -1861,8 +1863,8 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
case DEMO_CTRL_MENU(ACTION_LOAD, MENU_INFO):
case DEMO_CTRL_MENU(ACTION_CLEAR, MENU_INFO): {
if ((1 << sCurFileIdx) & sMempakFiles) {
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DLEFT) ||
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DLEFT) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DRIGHT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlToggleSwitch ^= 1;
@ -1875,7 +1877,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
func_8006376C(0x11, 8, dbCamera->sub.demoCtrlToggleSwitch ? 4 : 7, D_8012CF94);
func_8006376C(0x15, 8, dbCamera->sub.demoCtrlToggleSwitch ? 7 : 4, D_8012CF98);
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_A)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_A)) {
if (dbCamera->sub.demoCtrlToggleSwitch == 0) {
Audio_PlaySfxGeneral(NA_SE_SY_DECIDE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -1897,7 +1899,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
func_8006376C(0xD, 9, dbCamera->sub.demoCtrlToggleSwitch ? 1 : 6, "PRESS B BUTTON");
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_B)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_B)) {
Audio_PlaySfxGeneral(NA_SE_SY_CANCEL, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlMenu = 0;
@ -1933,8 +1935,8 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
func_8006376C(0x17, 7, 5, D_8012CFA4);
func_8006376C(0xD, 9, (dbCamera->sub.demoCtrlToggleSwitch != 0) ? 1 : 6, "PRESS B BUTTON");
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_A) ||
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_B)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_A) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_B)) {
Audio_PlaySfxGeneral(NA_SE_SY_DECIDE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (dbCamera->sub.demoCtrlMenu == DEMO_CTRL_MENU(ACTION_LOAD, MENU_SUCCESS)) {
@ -1956,8 +1958,8 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
func_8006376C(0x17, 7, 5, D_8012CFA4);
func_8006376C(0xD, 9, (dbCamera->sub.demoCtrlToggleSwitch != 0) ? 1 : 6, "PRESS B BUTTON");
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_A) ||
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_B)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_A) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_B)) {
Audio_PlaySfxGeneral(NA_SE_SY_DECIDE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlMenu -= 9;
@ -1970,12 +1972,12 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
goto block_1;
default: {
if (Mempak_Init(2)) {
sMempakFiles = Mempak_FindFile(2, 'A', 'E');
if (Mempak_Init(DBCAM_CONTROLLER_PORT)) {
sMempakFiles = Mempak_FindFile(DBCAM_CONTROLLER_PORT, 'A', 'E');
dbCamera->sub.demoCtrlMenu = DEMO_CTRL_MENU(ACTION_E, MENU_CALLBACK);
DbCamera_CalcMempakAllocSize();
if ((1 << sCurFileIdx) & sMempakFiles) {
sMempakFilesize = Mempak_GetFileSize(2, sCurFileIdx + 'A');
sMempakFilesize = Mempak_GetFileSize(DBCAM_CONTROLLER_PORT, sCurFileIdx + 'A');
dbCamera->sub.demoCtrlActionIdx = ACTION_LOAD;
} else {
sMempakFilesize = 0;
@ -1992,7 +1994,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
sp74[i * 2 + 0] = '-';
sp74[i * 2 + 1] = '\0';
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DRIGHT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (sCurFileIdx >= 4) {
@ -2002,14 +2004,14 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
}
if ((1 << sCurFileIdx) & sMempakFiles) {
sMempakFilesize = Mempak_GetFileSize(2, sCurFileIdx + 'A');
sMempakFilesize = Mempak_GetFileSize(DBCAM_CONTROLLER_PORT, sCurFileIdx + 'A');
dbCamera->sub.demoCtrlActionIdx = ACTION_LOAD;
} else {
sMempakFilesize = 0;
dbCamera->sub.demoCtrlActionIdx = ACTION_SAVE;
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DLEFT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DLEFT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (sCurFileIdx <= 0) {
@ -2019,7 +2021,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
}
if ((1 << sCurFileIdx) & sMempakFiles) {
sMempakFilesize = Mempak_GetFileSize(2, sCurFileIdx + 'A');
sMempakFilesize = Mempak_GetFileSize(DBCAM_CONTROLLER_PORT, sCurFileIdx + 'A');
dbCamera->sub.demoCtrlActionIdx = ACTION_LOAD;
} else {
sMempakFilesize = 0;
@ -2034,7 +2036,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
DbCamera_SetTextValue(DbCamera_GetMempakAllocSize(), sp74, 6);
func_8006376C(0xD, 9, 6, D_8012CF78); // NEED BYTE
func_8006376C(0x11, 9, 4, sp74);
DbCamera_SetTextValue(Mempak_GetFreeBytes(2), sp74, 6);
DbCamera_SetTextValue(Mempak_GetFreeBytes(DBCAM_CONTROLLER_PORT), sp74, 6);
func_8006376C(0xD, 0xA, 6, D_8012CF74); // FREE BYTE
func_8006376C(0x11, 0xA, 4, sp74);
if (sMempakFilesize != 0) {
@ -2052,24 +2054,24 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
func_8006376C(0xD, 0x1A, 5, D_8012CF60[0]);
func_8006376C(0x14, 0x1A, 5, D_8012CF70);
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DUP)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DUP)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlActionIdx = (dbCamera->sub.demoCtrlActionIdx - 1) % 4u;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DDOWN)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DDOWN)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlActionIdx = (dbCamera->sub.demoCtrlActionIdx + 1) % 4u;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_A)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_A)) {
Audio_PlaySfxGeneral(NA_SE_SY_DECIDE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlToggleSwitch = 0;
dbCamera->sub.demoCtrlMenu = DEMO_CTRL_MENU(dbCamera->sub.demoCtrlActionIdx, MENU_INFO);
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_B)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_B)) {
Audio_PlaySfxGeneral(NA_SE_SY_CANCEL, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlActionIdx = ACTION_E;
@ -2079,9 +2081,9 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
} else {
func_8006376C(0xC, 0x1A, 4, D_8012CF60[0]);
func_8006376C(0x13, 0x1A, 4, D_8012CF80);
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_B) ||
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DUP) ||
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DDOWN)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_B) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DUP) ||
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DDOWN)) {
Audio_PlaySfxGeneral(NA_SE_SY_CANCEL, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -2095,14 +2097,14 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
break;
default: {
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DUP)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DUP)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlMenu = DEMO_CTRL_MENU(ACTION_E, MENU_INFO);
dbCamera->sub.demoCtrlActionIdx = (dbCamera->sub.demoCtrlActionIdx - 1) % 4u;
sCurFileIdx = 0;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DDOWN)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DDOWN)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
dbCamera->sub.demoCtrlMenu = DEMO_CTRL_MENU(ACTION_E, MENU_INFO);
@ -2116,7 +2118,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
func_8006376C(4, 7, 5, D_8012CF4C);
func_8006376C(D_8016110C * 2 + 6, 7, 7, ">");
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CUP)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CUP)) {
if (D_8016110C > 0) {
D_8016110C--;
}
@ -2124,7 +2126,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
sDbCamAnim.curFrame = 0.0f;
sDbCamAnim.keyframe = 0;
sDbCamAnim.unk_04 = 0;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CDOWN)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CDOWN)) {
if (D_8016110C < 14) {
D_8016110C++;
}
@ -2132,7 +2134,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
sDbCamAnim.curFrame = 0.0f;
sDbCamAnim.keyframe = 0;
sDbCamAnim.unk_04 = 0;
} else if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CLEFT)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CLEFT)) {
sDbCamAnim.unk_0A = 0;
Interface_ChangeAlpha(2);
Letterbox_SetSizeTarget(0);
@ -2166,7 +2168,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_L)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_L)) {
if (sp74[sCurFileIdx] == '?') {
sLastFileIdx = -1;
D_801612EA = '*';
@ -2175,7 +2177,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
D_801612EA = sDbCameraCuts[idx1].letter;
}
if (1) {}
} else if (!CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L)) {
} else if (!CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L)) {
if (sLastFileIdx != -1) {
switch (sp74[sCurFileIdx]) {
case '?':
@ -2217,7 +2219,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
sLastFileIdx = -1;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_A)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_A)) {
if (sp74[sCurFileIdx] == '?') {
Audio_PlaySfxGeneral(NA_SE_SY_DECIDE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -2228,7 +2230,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_B)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_B)) {
if (sp74[sCurFileIdx] != '?' && sp74[sCurFileIdx] != '-') {
Audio_PlaySfxGeneral(NA_SE_SY_CANCEL, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -2237,7 +2239,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_R)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_R)) {
if (sp74[sCurFileIdx] != '?' && sp74[sCurFileIdx] != '-') {
Audio_PlaySfxGeneral(NA_SE_SY_DECIDE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
@ -2261,7 +2263,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DRIGHT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
if (sCurFileIdx == 0x1E) {
@ -2270,22 +2272,22 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
sCurFileIdx++;
}
}
if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_DLEFT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_DLEFT)) {
Audio_PlaySfxGeneral(NA_SE_SY_CURSOR, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
sCurFileIdx = (sCurFileIdx == 0) ? 0x1E : sCurFileIdx - 1;
}
if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L) &&
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CRIGHT)) {
if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L) &&
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CRIGHT)) {
for (i = 0; i < ARRAY_COUNT(sDbCameraCuts) - 1; i++) {
osSyncPrintf("###%2d:(%c) (%d %d) %d %d %d\n", i, sDbCameraCuts[i].letter,
sDbCameraCuts[i].position, sDbCameraCuts[i].lookAt, sDbCameraCuts[i].nFrames,
sDbCameraCuts[i].nPoints, sDbCameraCuts[i].mode);
}
DbCamera_PrintAllCuts(cam);
} else if (CHECK_BTN_ALL(sPlay->state.input[2].cur.button, BTN_L) &&
CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CLEFT)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].cur.button, BTN_L) &&
CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CLEFT)) {
Audio_PlaySfxGeneral(NA_SE_SY_GET_RUPY, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
&gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
for (i = 0; i < ARRAY_COUNT(sDbCameraCuts) - 1; i++) {
@ -2294,7 +2296,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
DbCamera_PrintCutBytes(&sDbCameraCuts[i]);
}
}
} else if (CHECK_BTN_ALL(sPlay->state.input[2].press.button, BTN_CRIGHT)) {
} else if (CHECK_BTN_ALL(sPlay->state.input[DBCAM_CONTROLLER_PORT].press.button, BTN_CRIGHT)) {
sDbCamAnim.curFrame = 0.0f;
sDbCamAnim.keyframe = 0;
sDbCamAnim.unk_04 = 0.0f;

4
src/code/debug_malloc.c
View file

@ -106,6 +106,6 @@ void DebugArena_Cleanup(void) {
__osMallocCleanup(&sDebugArena);
}
u8 DebugArena_IsInitalized(void) {
return __osMallocIsInitalized(&sDebugArena);
u8 DebugArena_IsInitialized(void) {
return __osMallocIsInitialized(&sDebugArena);
}

21
src/code/fault.c
View file

@ -352,18 +352,25 @@ void Fault_Sleep(u32 msec) {
Fault_SleepImpl(msec);
}
void PadMgr_RequestPadData(Input* input, s32 mode);
#ifndef AVOID_UB
void PadMgr_RequestPadData(Input* inputs, s32 gameRequest);
#endif
void Fault_PadCallback(Input* input) {
void Fault_PadCallback(Input* inputs) {
//! @bug This function is not called correctly, it is missing a leading PadMgr* argument. This
//! renders the crash screen unusable.
//! In Majora's Mask, PadMgr functions were changed to not require this argument, and this was
//! likely just not addressed when backporting.
PadMgr_RequestPadData(input, 0);
#ifndef AVOID_UB
PadMgr_RequestPadData(inputs, false);
#else
// Guarantee crashing behavior: false -> NULL, previous value in a2 is more often non-zero than zero
PadMgr_RequestPadData((PadMgr*)inputs, NULL, true);
#endif
}
void Fault_UpdatePadImpl(void) {
sFaultInstance->padCallback(&sFaultInstance->padInput);
sFaultInstance->padCallback(sFaultInstance->inputs);
}
/**
@ -376,7 +383,7 @@ void Fault_UpdatePadImpl(void) {
* DPad-Left continues and returns false
*/
u32 Fault_WaitForInputImpl(void) {
Input* input = &sFaultInstance->padInput;
Input* input = &sFaultInstance->inputs[0];
s32 count = 600;
u32 pressedBtn;
@ -651,7 +658,7 @@ void Fault_Wait5Seconds(void) {
* (L & R & Z) + DPad-Up + C-Down + C-Up + DPad-Down + DPad-Left + C-Left + C-Right + DPad-Right + (B & A & START)
*/
void Fault_WaitForButtonCombo(void) {
Input* input = &sFaultInstance->padInput;
Input* input = &sFaultInstance->inputs[0];
s32 state;
u32 s1;
u32 s2;
@ -853,7 +860,7 @@ void Fault_DrawMemDumpContents(const char* title, uintptr_t addr, u32 arg2) {
* @param cRightJump Unused parameter, pressing C-Right jumps to this address
*/
void Fault_DrawMemDump(uintptr_t pc, uintptr_t sp, uintptr_t cLeftJump, uintptr_t cRightJump) {
Input* input = &sFaultInstance->padInput;
Input* input = &sFaultInstance->inputs[0];
uintptr_t addr = pc;
s32 scrollCountdown;
u32 off;

4
src/code/game.c
View file

@ -227,10 +227,10 @@ void func_800C49F4(GraphicsContext* gfxCtx) {
CLOSE_DISPS(gfxCtx, "../game.c", 865);
}
void PadMgr_RequestPadData(PadMgr*, Input*, s32);
void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 gameRequest);
void GameState_ReqPadData(GameState* gameState) {
PadMgr_RequestPadData(&gPadMgr, &gameState->input[0], 1);
PadMgr_RequestPadData(&gPadMgr, gameState->input, true);
}
void GameState_Update(GameState* gameState) {

28
src/code/mempak.c
View file

@ -17,14 +17,14 @@ s32 Mempak_Init(s32 controllerNb) {
s32 pad;
s32 ret = false;
mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
if (!osPfsInitPak(mq, &sMempakPfsHandle, controllerNb)) {
ret = true;
}
osPfsFreeBlocks(&sMempakPfsHandle, &sMempakFreeBytes);
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
return ret;
}
@ -40,7 +40,7 @@ s32 Mempak_FindFile(s32 controllerNb, char start, char end) {
u32 bit = 1;
s32 flag = 0;
mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
for (idx = start; idx <= end; idx++) {
sMempakExtName[0] = idx - 0x27;
@ -57,7 +57,7 @@ s32 Mempak_FindFile(s32 controllerNb, char start, char end) {
osSyncPrintf("mempak: find '%c' (%d)\n", idx, error);
}
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
osSyncPrintf("mempak: find '%c' - '%c' %02x\n", start, end, flag);
return flag;
@ -69,7 +69,7 @@ s32 Mempak_Write(s32 controllerNb, char idx, void* buffer, s32 offset, s32 size)
s32 ret = false;
s32 pad;
mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
if (size < sMempakFreeBytes) {
error = osPfsReadWriteFile(&sMempakPfsHandle, sMempakFiles[idx - 'A'], 1, offset, size, buffer);
@ -78,7 +78,7 @@ s32 Mempak_Write(s32 controllerNb, char idx, void* buffer, s32 offset, s32 size)
}
osSyncPrintf("mempak: write %d byte '%c' (%d)->%d\n", size, idx, sMempakFiles[idx - 'A'], error);
}
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
return ret;
}
@ -89,7 +89,7 @@ s32 Mempak_Read(s32 controllerNb, char idx, void* buffer, s32 offset, s32 size)
s32 ret = false;
s32 pad;
mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
if (size < sMempakFreeBytes) {
error = osPfsReadWriteFile(&sMempakPfsHandle, sMempakFiles[idx - 'A'], 0, offset, size, buffer);
@ -98,7 +98,7 @@ s32 Mempak_Read(s32 controllerNb, char idx, void* buffer, s32 offset, s32 size)
}
osSyncPrintf("mempak: read %d byte '%c' (%d)<-%d\n", size, idx, sMempakFiles[idx - 'A'], error);
}
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
return ret;
}
@ -109,7 +109,7 @@ s32 Mempak_Alloc(s32 controllerNb, char* idx, s32 size) {
s32 i;
s32 pad;
mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
if (*idx >= 'A' && *idx < 'L') {
sMempakExtName[0] = *idx - 0x27;
@ -149,7 +149,7 @@ s32 Mempak_Alloc(s32 controllerNb, char* idx, s32 size) {
ret = 1;
}
}
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
return ret;
}
@ -159,7 +159,7 @@ s32 Mempak_DeleteFile(s32 controllerNb, char idx) {
s32 error;
s32 ret = false;
mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
sMempakExtName[0] = idx - 0x27;
error = osPfsDeleteFile(&sMempakPfsHandle, sMempakCompanyCode, sMempakGameCode, sMempakGameName, sMempakExtName);
@ -167,18 +167,18 @@ s32 Mempak_DeleteFile(s32 controllerNb, char idx) {
ret = true;
}
osSyncPrintf("mempak: delete '%c' (%d)\n", idx, error);
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
return ret;
}
s32 Mempak_GetFileSize(s32 controllerNb, char idx) {
OSMesgQueue* mq = PadMgr_LockSerialMesgQueue(&gPadMgr);
OSMesgQueue* mq = PadMgr_AcquireSerialEventQueue(&gPadMgr);
OSPfsState state;
s32 error = osPfsFileState(&sMempakPfsHandle, sMempakFiles[idx - 'A'], &state);
s32 pad;
PadMgr_UnlockSerialMesgQueue(&gPadMgr, mq);
PadMgr_ReleaseSerialEventQueue(&gPadMgr, mq);
if (error != 0) {
return 0;

447
src/code/padmgr.c
View file

@ -1,12 +1,74 @@
/**
* @file padmgr.c
*
* This file implements communicating with joybus devices at a high level and serving the results to other threads.
*
* Any device that can be plugged into one of the four controller ports such as a standard N64 controller is a joybus
* device. Some joybus devices are also located inside the cartridge such as EEPROM for save data or the Real-Time
* Clock, however neither of these are used in Zelda64 and so this type of communication is unimplemented. Of the
* possible devices that can be plugged into the controller ports, the only device that padmgr will recognize and
* attempt to communicate with is the standard N64 controller.
*
* Communicating with these devices is broken down into various layers:
*
* Other threads : The rest of the program that will use the polled data
* |
* PadMgr : Manages devices, submits polling commands at vertical retrace
* |
* Libultra osCont* routines : Interface for building commands and safely using the Serial Interface
* |
* Serial Interface : Hardware unit for sending joybus commands and receiving data via DMA
* |
* PIF : Forwards joybus commands and receives response data from the devices
* |---¬---¬---¬-------¬
* 1 2 3 4 5 : The joybus devices plugged into the four controller ports or on the cartridge
*
* Joybus communication is handled on another thread as polling and receiving controller data is a slow process; the
* N64 programming manual section 26.2.4.1 quotes 2 milliseconds as the expected delay from calling
* `osContStartReadData` to receiving the data. By running this on a separate thread to the game state, work can be
* done while waiting for this operation to complete.
*/
#include "global.h"
#include "vt.h"
s32 D_8012D280 = 1;
#define PADMGR_LOG(controllerNo, msg) \
if (1) { \
osSyncPrintf(VT_FGCOL(YELLOW)); \
/* padmgr: Controller %d: %s */ \
osSyncPrintf("padmgr: %dコン: %s\n", (controllerNo) + 1, (msg)); \
osSyncPrintf(VT_RST); \
} \
(void)0
OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) {
#define LOG_SEVERITY_NOLOG 0
#define LOG_SEVERITY_CRITICAL 1
#define LOG_SEVERITY_ERROR 2
#define LOG_SEVERITY_VERBOSE 3
s32 gPadMgrLogSeverity = LOG_SEVERITY_CRITICAL;
/**
* Acquires exclusive access to the serial event queue.
*
* When a DMA to/from PIF RAM completes, an SI interrupt is generated to notify the process that the DMA has completed
* and a message is posted to the serial event queue. If multiple processes are trying to use the SI at the same time
* it becomes ambiguous as to which DMA has completed, so a locking system is required to arbitrate access to the SI.
*
* Once the task requiring the serial event queue is complete, it should be released with a call to
* `PadMgr_ReleaseSerialEventQueue()`.
*
* If another process tries to acquire the event queue, the current thread will be blocked until the event queue is
* released. Note the possibility for a deadlock, if the thread that already holds the serial event queue attempts to
* acquire it again it will block forever.
*
* @return The message queue to which SI interrupt events are posted.
*
* @see PadMgr_ReleaseSerialEventQueue
*/
OSMesgQueue* PadMgr_AcquireSerialEventQueue(PadMgr* padMgr) {
OSMesgQueue* serialEventQueue = NULL;
if (D_8012D280 > 2) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE) {
// "serialMsgQ Waiting for lock"
osSyncPrintf("%2d %d serialMsgQロック待ち %08x %08x %08x\n", osGetThreadId(NULL),
MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, &serialEventQueue);
@ -14,7 +76,7 @@ OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) {
osRecvMesg(&padMgr->serialLockQueue, (OSMesg*)&serialEventQueue, OS_MESG_BLOCK);
if (D_8012D280 > 2) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE) {
// "serialMsgQ Locked"
osSyncPrintf("%2d %d serialMsgQをロックしました %08x\n", osGetThreadId(NULL),
MQ_GET_COUNT(&padMgr->serialLockQueue), serialEventQueue);
@ -23,8 +85,15 @@ OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr) {
return serialEventQueue;
}
void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* serialEventQueue) {
if (D_8012D280 > 2) {
/**
* Relinquishes access to the serial message queue, allowing another process to acquire and use it.
*
* @param serialEventQueue The serial message queue acquired by `PadMgr_AcquireSerialEventQueue`
*
* @see PadMgr_AcquireSerialEventQueue
*/
void PadMgr_ReleaseSerialEventQueue(PadMgr* padMgr, OSMesgQueue* serialEventQueue) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE) {
// "serialMsgQ Unlock"
osSyncPrintf("%2d %d serialMsgQロック解除します %08x %08x %08x\n", osGetThreadId(NULL),
MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, serialEventQueue);
@ -32,97 +101,99 @@ void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* serialEventQueue)
osSendMesg(&padMgr->serialLockQueue, (OSMesg)serialEventQueue, OS_MESG_BLOCK);
if (D_8012D280 > 2) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE) {
// "serialMsgQ Unlocked"
osSyncPrintf("%2d %d serialMsgQロック解除しました %08x %08x %08x\n", osGetThreadId(NULL),
MQ_GET_COUNT(&padMgr->serialLockQueue), padMgr, &padMgr->serialLockQueue, serialEventQueue);
}
}
/**
* Locks controller input data while padmgr is reading new inputs or another thread is using the current inputs.
* This prevents new inputs overwriting the current inputs while they are in use.
*
* @see PadMgr_UnlockPadData
*/
void PadMgr_LockPadData(PadMgr* padMgr) {
osRecvMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
}
/**
* Unlocks controller input data, allowing padmgr to read new inputs or another thread to access the most recently
* polled inputs.
*
* @see PadMgr_LockPadData
*/
void PadMgr_UnlockPadData(PadMgr* padMgr) {
osSendMesg(&padMgr->lockQueue, NULL, OS_MESG_BLOCK);
}
void PadMgr_RumbleControl(PadMgr* padMgr) {
static u32 errcnt = 0;
static u32 frame;
s32 temp = 1;
/**
* Activates the rumble pak for all controllers it is enabled on, stops it for all controllers it is disabled on and
* attempts to initialize it for a controller if it is not already initialized.
*/
void PadMgr_UpdateRumble(PadMgr* padMgr) {
static u32 sRumbleErrorCount = 0; // original name: "errcnt"
static u32 sRumbleUpdateCounter;
s32 motorStart = MOTOR_START; // required for matching?
s32 triedRumbleComm;
OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
s32 var4;
OSMesgQueue* serialEventQueue = PadMgr_AcquireSerialEventQueue(padMgr);
s32 ret;
s32 i;
triedRumbleComm = 0;
triedRumbleComm = false;
for (i = 0; i < 4; i++) {
for (i = 0; i < MAXCONTROLLERS; i++) {
if (padMgr->ctrlrIsConnected[i]) {
if (padMgr->padStatus[i].status & 1) {
if (padMgr->pakType[i] == temp) {
if (padMgr->rumbleEnable[i] != 0) {
if (padMgr->rumbleCounter[i] < 3) {
// clang-format off
if (1) {} osSyncPrintf(VT_FGCOL(YELLOW));
// clang-format on
// Check status for whether a controller pak is connected
if (padMgr->padStatus[i].status & CONT_CARD_ON) {
if (padMgr->pakType[i] == CONT_PAK_RUMBLE) {
if (padMgr->rumbleEnable[i]) {
if (padMgr->rumbleTimer[i] < 3) {
// "Rumble pack brrr"
PADMGR_LOG(i, "振動パック ぶるぶるぶるぶる");
// "Vibration pack jumble jumble"?
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック ぶるぶるぶるぶる");
osSyncPrintf(VT_RST);
// This should be the osMotorStart macro, however the temporary variable motorStart is
// currently required for matching
if (__osMotorAccess(&padMgr->rumblePfs[i], motorStart) != 0) {
padMgr->pakType[i] = CONT_PAK_NONE;
if (__osMotorAccess(&padMgr->pfs[i], temp) != 0) {
padMgr->pakType[i] = 0;
osSyncPrintf(VT_FGCOL(YELLOW));
// "A communication error has occurred with the vibration pack"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックで通信エラーが発生しました");
osSyncPrintf(VT_RST);
PADMGR_LOG(i, "振動パックで通信エラーが発生しました");
} else {
padMgr->rumbleCounter[i] = 3;
padMgr->rumbleTimer[i] = 3;
}
triedRumbleComm = 1;
triedRumbleComm = true;
}
} else {
if (padMgr->rumbleCounter[i] != 0) {
// clang-format off
if (1) {} osSyncPrintf(VT_FGCOL(YELLOW));
// clang-format on
if (padMgr->rumbleTimer[i] != 0) {
// "Stop vibration pack"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック 停止");
osSyncPrintf(VT_RST);
PADMGR_LOG(i, "振動パック 停止");
if (osMotorStop(&padMgr->rumblePfs[i]) != 0) {
padMgr->pakType[i] = CONT_PAK_NONE;
if (osMotorStop(&padMgr->pfs[i]) != 0) {
padMgr->pakType[i] = 0;
osSyncPrintf(VT_FGCOL(YELLOW));
// "A communication error has occurred with the vibration pack"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックで通信エラーが発生しました");
osSyncPrintf(VT_RST);
PADMGR_LOG(i, "振動パックで通信エラーが発生しました");
} else {
padMgr->rumbleCounter[i]--;
padMgr->rumbleTimer[i]--;
}
triedRumbleComm = 1;
triedRumbleComm = true;
}
}
}
} else {
if (padMgr->pakType[i] != 0) {
if (padMgr->pakType[i] == 1) {
osSyncPrintf(VT_FGCOL(YELLOW));
if (padMgr->pakType[i] != CONT_PAK_NONE) {
if (padMgr->pakType[i] == CONT_PAK_RUMBLE) {
// "It seems that a vibration pack was pulled out"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックが抜かれたようです");
osSyncPrintf(VT_RST);
padMgr->pakType[i] = 0;
PADMGR_LOG(i, "振動パックが抜かれたようです");
padMgr->pakType[i] = CONT_PAK_NONE;
} else {
osSyncPrintf(VT_FGCOL(YELLOW));
// "It seems that a controller pack that is not a vibration pack was pulled out"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1,
"振動パックではないコントローラパックが抜かれたようです");
osSyncPrintf(VT_RST);
padMgr->pakType[i] = 0;
PADMGR_LOG(i, "振動パックではないコントローラパックが抜かれたようです");
padMgr->pakType[i] = CONT_PAK_NONE;
}
}
}
@ -130,128 +201,145 @@ void PadMgr_RumbleControl(PadMgr* padMgr) {
}
if (!triedRumbleComm) {
i = frame % 4;
// Try to initialize the rumble pak for controller port `i` if a controller pak is connected and
// not already known to be an initialized a rumble pak
i = sRumbleUpdateCounter % MAXCONTROLLERS;
if (padMgr->ctrlrIsConnected[i] && (padMgr->padStatus[i].status & 1) && (padMgr->pakType[i] != 1)) {
var4 = osMotorInit(serialEventQueue, &padMgr->pfs[i], i);
if (padMgr->ctrlrIsConnected[i] && (padMgr->padStatus[i].status & CONT_CARD_ON) &&
padMgr->pakType[i] != CONT_PAK_RUMBLE) {
ret = osMotorInit(serialEventQueue, &padMgr->rumblePfs[i], i);
if (ret == 0) {
padMgr->pakType[i] = CONT_PAK_RUMBLE;
osMotorStart(&padMgr->rumblePfs[i]);
osMotorStop(&padMgr->rumblePfs[i]);
if (var4 == 0) {
padMgr->pakType[i] = 1;
osMotorStart(&padMgr->pfs[i]);
osMotorStop(&padMgr->pfs[i]);
osSyncPrintf(VT_FGCOL(YELLOW));
// "Recognized vibration pack"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パックを認識しました");
osSyncPrintf(VT_RST);
} else if (var4 == 11) {
padMgr->pakType[i] = 2;
} else if (var4 == 4) {
LOG_NUM("++errcnt", ++errcnt, "../padmgr.c", 282);
osSyncPrintf(VT_FGCOL(YELLOW));
PADMGR_LOG(i, "振動パックを認識しました");
} else if (ret == PFS_ERR_DEVICE) {
padMgr->pakType[i] = CONT_PAK_OTHER;
} else if (ret == PFS_ERR_CONTRFAIL) {
LOG_NUM("++errcnt", ++sRumbleErrorCount, "../padmgr.c", 282);
// "Controller pack communication error"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "コントローラパックの通信エラー");
osSyncPrintf(VT_RST);
PADMGR_LOG(i, "コントローラパックの通信エラー");
}
}
}
sRumbleUpdateCounter++;
frame++;
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
PadMgr_ReleaseSerialEventQueue(padMgr, serialEventQueue);
}
/**
* Immediately stops rumble on all controllers
*/
void PadMgr_RumbleStop(PadMgr* padMgr) {
s32 i;
OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
OSMesgQueue* serialEventQueue = PadMgr_AcquireSerialEventQueue(padMgr);
for (i = 0; i < 4; i++) {
if (osMotorInit(serialEventQueue, &padMgr->pfs[i], i) == 0) {
if ((gFaultMgr.msgId == 0) && (padMgr->rumbleOnFrames != 0)) {
osSyncPrintf(VT_FGCOL(YELLOW));
// "Stop vibration pack"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "振動パック 停止");
osSyncPrintf(VT_RST);
for (i = 0; i < MAXCONTROLLERS; i++) {
if (osMotorInit(serialEventQueue, &padMgr->rumblePfs[i], i) == 0) {
// If there is a rumble pak attached to this controller, stop it
if (gFaultMgr.msgId == 0 && padMgr->rumbleOnTimer != 0) {
// "Stop rumble pak"
PADMGR_LOG(i, "振動パック 停止");
}
osMotorStop(&padMgr->pfs[i]);
osMotorStop(&padMgr->rumblePfs[i]);
}
}
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
PadMgr_ReleaseSerialEventQueue(padMgr, serialEventQueue);
}
/**
* Prevents rumble for 3 VI, ~0.05 seconds at 60 VI/sec
*/
void PadMgr_RumbleReset(PadMgr* padMgr) {
padMgr->rumbleOffFrames = 3;
padMgr->rumbleOffTimer = 3;
}
void PadMgr_RumbleSetSingle(PadMgr* padMgr, u32 ctrlr, u32 rumble) {
padMgr->rumbleEnable[ctrlr] = rumble;
padMgr->rumbleOnFrames = 240;
/**
* Enables or disables rumble on controller port `port` for 240 VI,
* ~4 seconds at 60 VI/sec and ~4.8 seconds at 50 VI/sec
*/
void PadMgr_RumbleSetSingle(PadMgr* padMgr, u32 port, u32 rumble) {
padMgr->rumbleEnable[port] = rumble;
padMgr->rumbleOnTimer = 240;
}
void PadMgr_RumbleSet(PadMgr* padMgr, u8* ctrlrRumbles) {
/**
* Enables or disables rumble on all controller ports for 240 VI,
* ~4 seconds at 60 VI/sec and ~4.8 seconds at 50 VI/sec
*
* @param enable Array of u8 of length MAXCONTROLLERS containing either true or false to enable or disable rumble
* for that controller
*/
void PadMgr_RumbleSet(PadMgr* padMgr, u8* enable) {
s32 i;
for (i = 0; i < 4; i++) {
padMgr->rumbleEnable[i] = ctrlrRumbles[i];
for (i = 0; i < MAXCONTROLLERS; i++) {
padMgr->rumbleEnable[i] = enable[i];
}
padMgr->rumbleOnFrames = 240;
padMgr->rumbleOnTimer = 240;
}
void PadMgr_ProcessInputs(PadMgr* padMgr) {
/**
* Updates `padMgr->inputs` based on the error response of each controller
*/
void PadMgr_UpdateInputs(PadMgr* padMgr) {
s32 i;
Input* input;
OSContPad* padnow1; // original name
OSContPad* pad; // original name: "padnow1"
s32 buttonDiff;
PadMgr_LockPadData(padMgr);
input = &padMgr->inputs[0];
padnow1 = &padMgr->pads[0];
for (i = 0; i < padMgr->nControllers; i++, input++, padnow1++) {
for (input = &padMgr->inputs[0], pad = &padMgr->pads[0], i = 0; i < padMgr->nControllers; i++, input++, pad++) {
input->prev = input->cur;
if (1) {} // Necessary to match
switch (padnow1->errno) {
switch (pad->errno) {
case 0:
input->cur = *padnow1;
// No error, copy inputs
input->cur = *pad;
if (!padMgr->ctrlrIsConnected[i]) {
padMgr->ctrlrIsConnected[i] = true;
osSyncPrintf(VT_FGCOL(YELLOW));
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "認識しました"); // "Recognized"
osSyncPrintf(VT_RST);
// "Recognized"
PADMGR_LOG(i, "認識しました");
}
break;
case 4:
case (CHNL_ERR_OVERRUN >> 4):
// Overrun error, reuse previous inputs
input->cur = input->prev;
LOG_NUM("this->Key_switch[i]", padMgr->ctrlrIsConnected[i], "../padmgr.c", 380);
osSyncPrintf(VT_FGCOL(YELLOW));
// "Overrun error occurred"
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "オーバーランエラーが発生");
osSyncPrintf(VT_RST);
PADMGR_LOG(i, "オーバーランエラーが発生");
break;
case 8:
case (CHNL_ERR_NORESP >> 4):
// No response error, take inputs as 0
input->cur.button = 0;
input->cur.stick_x = 0;
input->cur.stick_y = 0;
input->cur.errno = padnow1->errno;
input->cur.errno = pad->errno;
if (padMgr->ctrlrIsConnected[i]) {
// If we get no response, consider the controller disconnected
padMgr->ctrlrIsConnected[i] = false;
padMgr->pakType[i] = 0;
padMgr->rumbleCounter[i] = 0xFF;
osSyncPrintf(VT_FGCOL(YELLOW));
// "Do not respond"?
osSyncPrintf("padmgr: %dコン: %s\n", i + 1, "応答しません");
osSyncPrintf(VT_RST);
padMgr->pakType[i] = CONT_PAK_NONE;
padMgr->rumbleTimer[i] = UINT8_MAX;
// "Not responding"
PADMGR_LOG(i, "応答しません");
}
break;
default:
LOG_HEX("padnow1->errno", padnow1->errno, "../padmgr.c", 396);
// Unknown error response
LOG_HEX("padnow1->errno", pad->errno, "../padmgr.c", 396);
Fault_AddHungupAndCrash("../padmgr.c", 397);
break;
}
// Calculate pressed and relative inputs
buttonDiff = input->prev.button ^ input->cur.button;
input->press.button |= (u16)(buttonDiff & input->cur.button);
input->rel.button |= (u16)(buttonDiff & input->prev.button);
@ -263,29 +351,43 @@ void PadMgr_ProcessInputs(PadMgr* padMgr) {
PadMgr_UnlockPadData(padMgr);
}
void PadMgr_HandleRetraceMsg(PadMgr* padMgr) {
void PadMgr_HandleRetrace(PadMgr* padMgr) {
s32 i;
OSMesgQueue* serialEventQueue = PadMgr_LockSerialMesgQueue(padMgr);
OSMesgQueue* serialEventQueue = PadMgr_AcquireSerialEventQueue(padMgr);
u32 mask;
// Begin reading controller data
osContStartReadData(serialEventQueue);
if (padMgr->retraceCallback) {
// Execute retrace callback
if (padMgr->retraceCallback != NULL) {
padMgr->retraceCallback(padMgr, padMgr->retraceCallbackValue);
}
// Wait for controller data
osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
osContGetReadData(padMgr->pads);
if (padMgr->preNMIShutdown) {
// If resetting, clear all controllers
if (padMgr->isResetting) {
bzero(padMgr->pads, sizeof(padMgr->pads));
}
PadMgr_ProcessInputs(padMgr);
// Update input data
PadMgr_UpdateInputs(padMgr);
// Query controller status for all controllers
osContStartQuery(serialEventQueue);
osRecvMesg(serialEventQueue, NULL, OS_MESG_BLOCK);
osContGetQuery(padMgr->padStatus);
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
PadMgr_ReleaseSerialEventQueue(padMgr, serialEventQueue);
// Update the state of connected controllers
mask = 0;
for (i = 0; i < 4; i++) {
for (i = 0; i < MAXCONTROLLERS; i++) {
if (padMgr->padStatus[i].errno == 0) {
// Only standard N64 controllers are supported
if (padMgr->padStatus[i].type == CONT_TYPE_NORMAL) {
mask |= 1 << i;
} else {
@ -298,53 +400,64 @@ void PadMgr_HandleRetraceMsg(PadMgr* padMgr) {
padMgr->validCtrlrsMask = mask;
if (gFaultMgr.msgId != 0) {
// If fault is active, no rumble
PadMgr_RumbleStop(padMgr);
} else if (padMgr->rumbleOffFrames > 0) {
--padMgr->rumbleOffFrames;
} else if (padMgr->rumbleOffTimer > 0) {
// If the rumble off timer is active, no rumble
--padMgr->rumbleOffTimer;
PadMgr_RumbleStop(padMgr);
} else if (padMgr->rumbleOnFrames == 0) {
} else if (padMgr->rumbleOnTimer == 0) {
// If the rumble on timer is inactive, no rumble
PadMgr_RumbleStop(padMgr);
} else if (!padMgr->preNMIShutdown) {
PadMgr_RumbleControl(padMgr);
--padMgr->rumbleOnFrames;
} else if (!padMgr->isResetting) {
// If not resetting, update rumble
PadMgr_UpdateRumble(padMgr);
--padMgr->rumbleOnTimer;
}
}
void PadMgr_HandlePreNMI(PadMgr* padMgr) {
osSyncPrintf("padmgr_HandlePreNMI()\n");
padMgr->preNMIShutdown = true;
padMgr->isResetting = true;
PadMgr_RumbleReset(padMgr);
}
void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 mode) {
/**
* Fetches the most recently polled inputs from padmgr
*
* @param inputs Array of Input of length MAXCONTROLLERS to copy inputs into
* @param gamePoll True if polling inputs for updating the game state
*/
void PadMgr_RequestPadData(PadMgr* padMgr, Input* inputs, s32 gameRequest) {
s32 i;
Input* ogInput;
Input* newInput;
Input* inputIn;
Input* inputOut;
s32 buttonDiff;
PadMgr_LockPadData(padMgr);
ogInput = &padMgr->inputs[0];
newInput = &inputs[0];
for (i = 0; i < 4; i++) {
if (mode != 0) {
*newInput = *ogInput;
ogInput->press.button = 0;
ogInput->press.stick_x = 0;
ogInput->press.stick_y = 0;
ogInput->rel.button = 0;
for (inputIn = &padMgr->inputs[0], inputOut = &inputs[0], i = 0; i < MAXCONTROLLERS; i++, inputIn++, inputOut++) {
if (gameRequest) {
// Copy inputs as-is, press and rel are calculated prior in `PadMgr_UpdateInputs`
*inputOut = *inputIn;
// Zero parts of the press and rel inputs in the polled inputs so they are not read more than once
inputIn->press.button = 0;
inputIn->press.stick_x = 0;
inputIn->press.stick_y = 0;
inputIn->rel.button = 0;
} else {
newInput->prev = newInput->cur;
newInput->cur = ogInput->cur;
buttonDiff = newInput->prev.button ^ newInput->cur.button;
newInput->press.button = newInput->cur.button & buttonDiff;
newInput->rel.button = newInput->prev.button & buttonDiff;
PadUtils_UpdateRelXY(newInput);
newInput->press.stick_x += (s8)(newInput->cur.stick_x - newInput->prev.stick_x);
newInput->press.stick_y += (s8)(newInput->cur.stick_y - newInput->prev.stick_y);
// Take as the previous inputs the inputs that are currently in the destination array
inputOut->prev = inputOut->cur;
// Copy current inputs from the polled inputs
inputOut->cur = inputIn->cur;
// Calculate press and rel from these
buttonDiff = inputOut->prev.button ^ inputOut->cur.button;
inputOut->press.button = inputOut->cur.button & buttonDiff;
inputOut->rel.button = inputOut->prev.button & buttonDiff;
PadUtils_UpdateRelXY(inputOut);
inputOut->press.stick_x += (s8)(inputOut->cur.stick_x - inputOut->prev.stick_x);
inputOut->press.stick_y += (s8)(inputOut->cur.stick_y - inputOut->prev.stick_y);
}
ogInput++;
newInput++;
}
PadMgr_UnlockPadData(padMgr);
@ -358,7 +471,7 @@ void PadMgr_ThreadEntry(PadMgr* padMgr) {
exit = false;
while (!exit) {
if ((D_8012D280 > 2) && MQ_IS_EMPTY(&padMgr->interruptQueue)) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE && MQ_IS_EMPTY(&padMgr->interruptQueue)) {
// "Waiting for controller thread event"
osSyncPrintf("コントローラスレッドイベント待ち %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
}
@ -368,16 +481,15 @@ void PadMgr_ThreadEntry(PadMgr* padMgr) {
switch (*msg) {
case OS_SC_RETRACE_MSG:
if (D_8012D280 > 2) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE) {
osSyncPrintf("padmgr_HandleRetraceMsg START %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
}
PadMgr_HandleRetraceMsg(padMgr);
PadMgr_HandleRetrace(padMgr);
if (D_8012D280 > 2) {
if (gPadMgrLogSeverity >= LOG_SEVERITY_VERBOSE) {
osSyncPrintf("padmgr_HandleRetraceMsg END %lld\n", OS_CYCLES_TO_USEC(osGetTime()));
}
break;
case OS_SC_PRE_NMI_MSG:
PadMgr_HandlePreNMI(padMgr);
@ -401,13 +513,16 @@ void PadMgr_Init(PadMgr* padMgr, OSMesgQueue* serialEventQueue, IrqMgr* irqMgr,
osCreateMesgQueue(&padMgr->interruptQueue, padMgr->interruptMsgBuf, ARRAY_COUNT(padMgr->interruptMsgBuf));
IrqMgr_AddClient(padMgr->irqMgr, &padMgr->irqClient, &padMgr->interruptQueue);
osCreateMesgQueue(&padMgr->serialLockQueue, padMgr->serialLockMsgBuf, ARRAY_COUNT(padMgr->serialLockMsgBuf));
PadMgr_UnlockSerialMesgQueue(padMgr, serialEventQueue);
osCreateMesgQueue(&padMgr->lockQueue, padMgr->lockMsgBuf, ARRAY_COUNT(padMgr->lockMsgBuf));
osCreateMesgQueue(&padMgr->serialLockQueue, &padMgr->serialMsg, 1);
PadMgr_ReleaseSerialEventQueue(padMgr, serialEventQueue);
osCreateMesgQueue(&padMgr->lockQueue, &padMgr->lockMsg, 1);
PadMgr_UnlockPadData(padMgr);
PadSetup_Init(serialEventQueue, (u8*)&padMgr->validCtrlrsMask, padMgr->padStatus);
padMgr->nControllers = 4;
padMgr->nControllers = MAXCONTROLLERS;
osContSetCh(padMgr->nControllers);
osCreateThread(&padMgr->thread, id, (void (*)(void*))PadMgr_ThreadEntry, padMgr, stack, priority);

4
src/code/padsetup.c
View file

@ -9,16 +9,16 @@ s32 PadSetup_Init(OSMesgQueue* mq, u8* outMask, OSContStatus* status) {
if (ret != 0) {
return ret;
}
if (*outMask == 0xFF) {
if (osContStartQuery(mq) != 0) {
return 1;
}
osRecvMesg(mq, NULL, OS_MESG_BLOCK);
osContGetQuery(status);
*outMask = 0;
for (i = 0; i < 4; i++) {
for (i = 0; i < MAXCONTROLLERS; i++) {
switch (status[i].errno) {
case 0:
if (status[i].type == CONT_TYPE_NORMAL) {

2
src/code/speed_meter.c
View file

@ -167,7 +167,7 @@ void SpeedMeter_DrawAllocEntries(SpeedMeter* meter, GraphicsContext* gfxCtx, Gam
y = 212;
if (SREG(0) > 2) {
if (ZeldaArena_IsInitalized()) {
if (ZeldaArena_IsInitialized()) {
ZeldaArena_GetSizes(&zeldaFreeMax, &zeldaFree, &zeldaAlloc);
SpeedMeter_InitAllocEntry(&entry, zeldaFree + zeldaAlloc, zeldaAlloc, GPACK_RGBA5551(0, 0, 255, 1),
GPACK_RGBA5551(255, 255, 255, 1), ulx, lrx, y, y + 1);

4
src/code/system_malloc.c
View file

@ -105,6 +105,6 @@ void SystemArena_Cleanup(void) {
__osMallocCleanup(&gSystemArena);
}
u8 SystemArena_IsInitalized(void) {
return __osMallocIsInitalized(&gSystemArena);
u8 SystemArena_IsInitialized(void) {
return __osMallocIsInitialized(&gSystemArena);
}

2
src/code/z_actor.c
View file

@ -2939,7 +2939,7 @@ void func_800328D4(PlayState* play, ActorContext* actorCtx, Player* player, u32
if ((actor->update != NULL) && ((Player*)actor != player) && CHECK_FLAG_ALL(actor->flags, ACTOR_FLAG_0)) {
// This block below is for determining the closest actor to player in determining the volume
// used while playing enemy bgm music
// used while playing enemy background music
if ((actorCategory == ACTORCAT_ENEMY) && CHECK_FLAG_ALL(actor->flags, ACTOR_FLAG_0 | ACTOR_FLAG_2) &&
(actor->xyzDistToPlayerSq < SQ(500.0f)) && (actor->xyzDistToPlayerSq < sbgmEnemyDistSq)) {
actorCtx->targetCtx.bgmEnemy = actor;

321
src/code/z_camera.c
View file

@ -68,8 +68,8 @@ f32 Camera_InterpolateCurve(f32 a, f32 b) {
}
/*
* Performs linear interpoloation between `cur` and `target`. If `cur` is within
* `minDiff` units, The result is rounded up to `target`
* Performs linear interpolation between `cur` and `target`. If `cur` is within
* `minDiff` units, the result is rounded up to `target`
*/
f32 Camera_LERPCeilF(f32 target, f32 cur, f32 stepScale, f32 minDiff) {
f32 diff = target - cur;
@ -87,8 +87,8 @@ f32 Camera_LERPCeilF(f32 target, f32 cur, f32 stepScale, f32 minDiff) {
}
/*
* Performs linear interpoloation between `cur` and `target`. If `cur` is within
* `minDiff` units, The result is rounded down to `cur`
* Performs linear interpolation between `cur` and `target`. If `cur` is within
* `minDiff` units, the result is rounded down to `cur`
*/
f32 Camera_LERPFloorF(f32 target, f32 cur, f32 stepScale, f32 minDiff) {
f32 diff = target - cur;
@ -106,8 +106,8 @@ f32 Camera_LERPFloorF(f32 target, f32 cur, f32 stepScale, f32 minDiff) {
}
/*
* Performs linear interpoloation between `cur` and `target`. If `cur` is within
* `minDiff` units, The result is rounded up to `target`
* Performs linear interpolation between `cur` and `target`. If `cur` is within
* `minDiff` units, the result is rounded up to `target`
*/
s16 Camera_LERPCeilS(s16 target, s16 cur, f32 stepScale, s16 minDiff) {
s16 diff = target - cur;
@ -125,8 +125,8 @@ s16 Camera_LERPCeilS(s16 target, s16 cur, f32 stepScale, s16 minDiff) {
}
/*
* Performs linear interpoloation between `cur` and `target`. If `cur` is within
* `minDiff` units, The result is rounded down to `cur`
* Performs linear interpolation between `cur` and `target`. If `cur` is within
* `minDiff` units, the result is rounded down to `cur`
*/
s16 Camera_LERPFloorS(s16 target, s16 cur, f32 stepScale, s16 minDiff) {
s16 diff = target - cur;
@ -144,8 +144,8 @@ s16 Camera_LERPFloorS(s16 target, s16 cur, f32 stepScale, s16 minDiff) {
}
/*
* Performs linear interpoloation between `cur` and `target`. If `cur` is within
* `minDiff` units, The result is rounded up to `target`
* Performs linear interpolation between `cur` and `target`. If `cur` is within
* `minDiff` units, the result is rounded up to `target`
*/
void Camera_LERPCeilVec3f(Vec3f* target, Vec3f* cur, f32 yStepScale, f32 xzStepScale, f32 minDiff) {
cur->x = Camera_LERPCeilF(target->x, cur->x, xzStepScale, minDiff);
@ -155,7 +155,7 @@ void Camera_LERPCeilVec3f(Vec3f* target, Vec3f* cur, f32 yStepScale, f32 xzStepS
void func_80043ABC(Camera* camera) {
camera->yawUpdateRateInv = 100.0f;
camera->pitchUpdateRateInv = R_CAM_DEFA_PHI_UPDRATE;
camera->pitchUpdateRateInv = R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV;
camera->rUpdateRateInv = OREG(6);
camera->xzOffsetUpdateRate = CAM_DATA_SCALED(OREG(2));
camera->yOffsetUpdateRate = CAM_DATA_SCALED(OREG(3));
@ -574,71 +574,83 @@ s16 Camera_XZAngle(Vec3f* to, Vec3f* from) {
return CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(from->x - to->x, from->z - to->z)));
}
s16 func_80044ADC(Camera* camera, s16 yaw, s16 arg2) {
static f32 D_8015CE50;
static f32 D_8015CE54;
static CamColChk D_8015CE58;
s16 Camera_GetPitchAdjFromFloorHeightDiffs(Camera* camera, s16 viewYaw, s16 initAndReturnZero) {
static f32 sFloorYNear;
static f32 sFloorYFar;
static CamColChk sFarColChk;
Vec3f playerPos;
Vec3f rotatedPos;
Vec3f nearPos;
Vec3f floorNorm;
f32 temp_f2;
s16 temp_s0;
s16 temp_s1;
f32 phi_f18;
f32 sinYaw;
f32 cosYaw;
f32 checkOffsetY;
s16 pitchNear;
s16 pitchFar;
f32 floorYDiffFar;
f32 viewForwardsUnitX;
f32 viewForwardsUnitZ;
s32 bgId;
f32 sp30;
f32 sp2C;
f32 phi_f16;
f32 nearDist;
f32 farDist;
f32 floorYDiffNear;
f32 playerHeight;
sinYaw = Math_SinS(yaw);
cosYaw = Math_CosS(yaw);
viewForwardsUnitX = Math_SinS(viewYaw);
viewForwardsUnitZ = Math_CosS(viewYaw);
playerHeight = Player_GetHeight(camera->player);
temp_f2 = CAM_DATA_SCALED(OREG(19)) * playerHeight;
sp30 = CAM_DATA_SCALED(OREG(17)) * playerHeight;
sp2C = CAM_DATA_SCALED(OREG(18)) * playerHeight;
checkOffsetY = CAM_DATA_SCALED(R_CAM_PITCH_FLOOR_CHECK_OFFSET_Y_FAC) * playerHeight;
nearDist = CAM_DATA_SCALED(R_CAM_PITCH_FLOOR_CHECK_NEAR_DIST_FAC) * playerHeight;
farDist = CAM_DATA_SCALED(R_CAM_PITCH_FLOOR_CHECK_FAR_DIST_FAC) * playerHeight;
playerPos.x = camera->playerPosRot.pos.x;
playerPos.y = camera->playerGroundY + temp_f2;
playerPos.y = camera->playerGroundY + checkOffsetY;
playerPos.z = camera->playerPosRot.pos.z;
rotatedPos.x = playerPos.x + (sp30 * sinYaw);
rotatedPos.y = playerPos.y;
rotatedPos.z = playerPos.z + (sp30 * cosYaw);
if (arg2 || (camera->play->state.frames % 2) == 0) {
D_8015CE58.pos.x = playerPos.x + (sp2C * sinYaw);
D_8015CE58.pos.y = playerPos.y;
D_8015CE58.pos.z = playerPos.z + (sp2C * cosYaw);
Camera_BGCheckInfo(camera, &playerPos, &D_8015CE58);
if (arg2) {
D_8015CE50 = D_8015CE54 = camera->playerGroundY;
nearPos.x = playerPos.x + (nearDist * viewForwardsUnitX);
nearPos.y = playerPos.y;
nearPos.z = playerPos.z + (nearDist * viewForwardsUnitZ);
if (initAndReturnZero || (camera->play->state.frames % 2) == 0) {
sFarColChk.pos.x = playerPos.x + (farDist * viewForwardsUnitX);
sFarColChk.pos.y = playerPos.y;
sFarColChk.pos.z = playerPos.z + (farDist * viewForwardsUnitZ);
Camera_BGCheckInfo(camera, &playerPos, &sFarColChk);
if (initAndReturnZero) {
sFloorYNear = sFloorYFar = camera->playerGroundY;
}
} else {
sp2C = OLib_Vec3fDistXZ(&playerPos, &D_8015CE58.pos);
D_8015CE58.pos.x += D_8015CE58.norm.x * 5.0f;
D_8015CE58.pos.y += D_8015CE58.norm.y * 5.0f;
D_8015CE58.pos.z += D_8015CE58.norm.z * 5.0f;
if (sp2C < sp30) {
sp30 = sp2C;
D_8015CE50 = D_8015CE54 = Camera_GetFloorYLayer(camera, &floorNorm, &D_8015CE58.pos, &bgId);
farDist = OLib_Vec3fDistXZ(&playerPos, &sFarColChk.pos);
sFarColChk.pos.x += sFarColChk.norm.x * 5.0f;
sFarColChk.pos.y += sFarColChk.norm.y * 5.0f;
sFarColChk.pos.z += sFarColChk.norm.z * 5.0f;
if (nearDist > farDist) {
nearDist = farDist;
sFloorYNear = sFloorYFar = Camera_GetFloorYLayer(camera, &floorNorm, &sFarColChk.pos, &bgId);
} else {
D_8015CE50 = Camera_GetFloorYLayer(camera, &floorNorm, &rotatedPos, &bgId);
D_8015CE54 = Camera_GetFloorYLayer(camera, &floorNorm, &D_8015CE58.pos, &bgId);
sFloorYNear = Camera_GetFloorYLayer(camera, &floorNorm, &nearPos, &bgId);
sFloorYFar = Camera_GetFloorYLayer(camera, &floorNorm, &sFarColChk.pos, &bgId);
}
if (D_8015CE50 == BGCHECK_Y_MIN) {
D_8015CE50 = camera->playerGroundY;
if (sFloorYNear == BGCHECK_Y_MIN) {
sFloorYNear = camera->playerGroundY;
}
if (D_8015CE54 == BGCHECK_Y_MIN) {
D_8015CE54 = D_8015CE50;
if (sFloorYFar == BGCHECK_Y_MIN) {
sFloorYFar = sFloorYNear;
}
}
phi_f16 = CAM_DATA_SCALED(OREG(20)) * (D_8015CE50 - camera->playerGroundY);
phi_f18 = (1.0f - CAM_DATA_SCALED(OREG(20))) * (D_8015CE54 - camera->playerGroundY);
temp_s0 = CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(phi_f16, sp30)));
temp_s1 = CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(phi_f18, sp2C)));
return temp_s0 + temp_s1;
floorYDiffNear = CAM_DATA_SCALED(R_CAM_PITCH_FLOOR_CHECK_NEAR_WEIGHT) * (sFloorYNear - camera->playerGroundY);
floorYDiffFar =
(1.0f - CAM_DATA_SCALED(R_CAM_PITCH_FLOOR_CHECK_NEAR_WEIGHT)) * (sFloorYFar - camera->playerGroundY);
pitchNear = CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(floorYDiffNear, nearDist)));
pitchFar = CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(floorYDiffFar, farDist)));
return pitchNear + pitchFar;
}
/**
@ -695,12 +707,12 @@ Vec3f* Camera_CalcUpFromPitchYawRoll(Vec3f* viewUp, s16 pitch, s16 yaw, s16 roll
f32 Camera_ClampLERPScale(Camera* camera, f32 maxLERPScale) {
f32 ret;
if (camera->atLERPStepScale < CAM_DATA_SCALED(R_AT_LERP_MIN)) {
ret = CAM_DATA_SCALED(R_AT_LERP_MIN);
if (camera->atLERPStepScale < CAM_DATA_SCALED(R_CAM_AT_LERP_STEP_SCALE_MIN)) {
ret = CAM_DATA_SCALED(R_CAM_AT_LERP_STEP_SCALE_MIN);
} else if (camera->atLERPStepScale >= maxLERPScale) {
ret = maxLERPScale;
} else {
ret = CAM_DATA_SCALED(R_AT_LERP_SCALE) * camera->atLERPStepScale;
ret = CAM_DATA_SCALED(R_CAM_AT_LERP_STEP_SCALE_FAC) * camera->atLERPStepScale;
}
return ret;
@ -1277,7 +1289,7 @@ s16 Camera_CalcDefaultPitch(Camera* camera, s16 arg1, s16 arg2, s16 arg3) {
if (ABS(target) < absCur) {
stepScale = (1.0f / camera->pitchUpdateRateInv) * 3.0f;
} else {
t = absCur * (1.0f / R_CAM_MAX_PHI);
t = absCur * (1.0f / R_CAM_MAX_PITCH);
pad = Camera_InterpolateCurve(0.8f, 1.0f - t);
stepScale = (1.0f / camera->pitchUpdateRateInv) * pad;
}
@ -1523,24 +1535,26 @@ s32 Camera_Normal1(Camera* camera) {
Camera_LERPCeilF(rwData->swing.swingUpdateRate + (f32)(rwData->swing.swingUpdateRateTimer * 2),
camera->yawUpdateRateInv, sp98, rate);
camera->pitchUpdateRateInv =
Camera_LERPCeilF((f32)R_CAM_DEFA_PHI_UPDRATE + (f32)(rwData->swing.swingUpdateRateTimer * 2),
Camera_LERPCeilF((f32)R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV + (f32)(rwData->swing.swingUpdateRateTimer * 2),
camera->pitchUpdateRateInv, sp9C, rate);
rwData->swing.swingUpdateRateTimer--;
} else {
camera->yawUpdateRateInv = Camera_LERPCeilF(rwData->swing.swingUpdateRate -
((OREG(49) * 0.01f) * rwData->swing.swingUpdateRate * sp94),
camera->yawUpdateRateInv, sp98, rate);
camera->pitchUpdateRateInv = Camera_LERPCeilF(R_CAM_DEFA_PHI_UPDRATE, camera->pitchUpdateRateInv, sp9C, rate);
camera->pitchUpdateRateInv =
Camera_LERPCeilF(R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV, camera->pitchUpdateRateInv, sp9C, rate);
}
camera->pitchUpdateRateInv = Camera_LERPCeilF(R_CAM_DEFA_PHI_UPDRATE, camera->pitchUpdateRateInv, sp9C, rate);
camera->pitchUpdateRateInv =
Camera_LERPCeilF(R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV, camera->pitchUpdateRateInv, sp9C, rate);
camera->xzOffsetUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(2)), camera->xzOffsetUpdateRate, spA0, rate);
camera->yOffsetUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(3)), camera->yOffsetUpdateRate, sp9C, rate);
camera->fovUpdateRate =
Camera_LERPCeilF(CAM_DATA_SCALED(OREG(4)), camera->yOffsetUpdateRate, camera->speedRatio * 0.05f, rate);
if (roData->interfaceFlags & 1) {
t = func_80044ADC(camera, atEyeGeo.yaw - 0x7FFF, 0);
t = Camera_GetPitchAdjFromFloorHeightDiffs(camera, atEyeGeo.yaw - 0x7FFF, false);
sp9C = ((1.0f / roData->unk_10) * 0.5f) * (1.0f - camera->speedRatio);
rwData->slopePitchAdj =
Camera_LERPCeilS(t, rwData->slopePitchAdj, ((1.0f / roData->unk_10) * 0.5f) + sp9C, 0xF);
@ -1670,7 +1684,7 @@ s32 Camera_Normal2(Camera* camera) {
playerHeight = Player_GetHeight(camera->player);
yNormal =
(1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
if (R_RELOAD_CAM_PARAMS) {
Camera_CopyPREGToModeValues(camera);
@ -1740,7 +1754,8 @@ s32 Camera_Normal2(Camera* camera) {
camera->yawUpdateRateInv = Camera_LERPCeilF(roData->unk_0C, camera->yawUpdateRateInv * camera->speedRatio,
CAM_DATA_SCALED(OREG(25)), 0.1f);
camera->pitchUpdateRateInv = Camera_LERPCeilF(OREG(7), camera->pitchUpdateRateInv, spA0, 0.1f);
camera->pitchUpdateRateInv =
Camera_LERPCeilF(R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV, camera->pitchUpdateRateInv, spA0, 0.1f);
camera->xzOffsetUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(2)), camera->xzOffsetUpdateRate, spA4, 0.1f);
camera->yOffsetUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(3)), camera->yOffsetUpdateRate, spA0, 0.1f);
camera->fovUpdateRate =
@ -1870,9 +1885,10 @@ s32 Camera_Normal3(Camera* camera) {
rwData->unk_20 = camera->playerGroundY;
rwData->swing.unk_16 = rwData->swing.unk_14 = rwData->swing.unk_18 = 0;
rwData->swing.swingUpdateRate = roData->yawUpdateSpeed;
rwData->yawUpdAmt = (s16)((s16)(playerPosRot->rot.y - 0x7FFF) - sp7C.yaw) * (1.0f / OREG(23));
rwData->yawUpdAmt =
(s16)((s16)(playerPosRot->rot.y - 0x7FFF) - sp7C.yaw) * (1.0f / R_CAM_DEFAULT_ANIM_TIME);
rwData->distTimer = 10;
rwData->yawTimer = OREG(23);
rwData->yawTimer = R_CAM_DEFAULT_ANIM_TIME;
camera->animState = 1;
rwData->swing.swingUpdateRateTimer = 0;
}
@ -1887,20 +1903,22 @@ s32 Camera_Normal3(Camera* camera) {
if (rwData->swing.swingUpdateRateTimer != 0) {
camera->yawUpdateRateInv = Camera_LERPCeilF(roData->yawUpdateSpeed + (rwData->swing.swingUpdateRateTimer * 2),
camera->yawUpdateRateInv, sp98, 0.1f);
camera->pitchUpdateRateInv = Camera_LERPCeilF((f32)OREG(7) + (rwData->swing.swingUpdateRateTimer * 2),
camera->pitchUpdateRateInv, sp94, 0.1f);
camera->pitchUpdateRateInv =
Camera_LERPCeilF((f32)R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV + (rwData->swing.swingUpdateRateTimer * 2),
camera->pitchUpdateRateInv, sp94, 0.1f);
if (1) {}
rwData->swing.swingUpdateRateTimer--;
} else {
camera->yawUpdateRateInv = Camera_LERPCeilF(roData->yawUpdateSpeed, camera->yawUpdateRateInv, sp98, 0.1f);
camera->pitchUpdateRateInv = Camera_LERPCeilF(OREG(7), camera->pitchUpdateRateInv, sp94, 0.1f);
camera->pitchUpdateRateInv =
Camera_LERPCeilF(R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV, camera->pitchUpdateRateInv, sp94, 0.1f);
}
camera->xzOffsetUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(2)), camera->xzOffsetUpdateRate, sp98, 0.1f);
camera->yOffsetUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(3)), camera->yOffsetUpdateRate, sp94, 0.1f);
camera->fovUpdateRate = Camera_LERPCeilF(CAM_DATA_SCALED(OREG(4)), camera->fovUpdateRate, sp94, 0.1f);
t2 = func_80044ADC(camera, sp7C.yaw - 0x7FFF, 1);
t2 = Camera_GetPitchAdjFromFloorHeightDiffs(camera, sp7C.yaw - 0x7FFF, true);
sp94 = ((1.0f / roData->unk_10) * 0.5f);
temp_f0 = (((1.0f / roData->unk_10) * 0.5f) * (1.0f - camera->speedRatio));
rwData->curPitch = Camera_LERPCeilS(t2, rwData->curPitch, sp94 + temp_f0, 0xF);
@ -1915,11 +1933,11 @@ s32 Camera_Normal3(Camera* camera) {
phi_a0 = roData->pitchTarget - rwData->curPitch;
sp84.pitch = Camera_LERPCeilS(phi_a0, sp74.pitch, 1.0f / camera->pitchUpdateRateInv, 0xA);
if (OREG(5) < sp84.pitch) {
sp84.pitch = OREG(5);
if (sp84.pitch > R_CAM_MAX_PITCH) {
sp84.pitch = R_CAM_MAX_PITCH;
}
if (sp84.pitch < OREG(34)) {
sp84.pitch = OREG(34);
if (sp84.pitch < R_CAM_MIN_PITCH_1) {
sp84.pitch = R_CAM_MIN_PITCH_1;
}
phi_a0 = playerPosRot->rot.y - (s16)(sp74.yaw - 0x7FFF);
@ -1990,7 +2008,8 @@ s32 Camera_Parallel1(Camera* camera) {
playerHeight = Player_GetHeight(camera->player);
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(OREG(46))) - (CAM_DATA_SCALED(OREG(46)) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->distTarget = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
@ -2022,7 +2041,7 @@ s32 Camera_Parallel1(Camera* camera) {
if (roData->interfaceFlags & 4) {
rwData->animTimer = 20;
} else {
rwData->animTimer = OREG(23);
rwData->animTimer = R_CAM_DEFAULT_ANIM_TIME;
}
rwData->unk_00.x = 0.0f;
rwData->yTarget = playerPosRot->pos.y - camera->playerPosDelta.y;
@ -2069,7 +2088,7 @@ s32 Camera_Parallel1(Camera* camera) {
Camera_LERPCeilF(CAM_DATA_SCALED(OREG(4)), camera->fovUpdateRate, camera->speedRatio * 0.05f, 0.1f);
if (roData->interfaceFlags & 1) {
tangle = func_80044ADC(camera, atToEyeDir.yaw - 0x7FFF, 1);
tangle = Camera_GetPitchAdjFromFloorHeightDiffs(camera, atToEyeDir.yaw - 0x7FFF, true);
spB8 = ((1.0f / roData->unk_0C) * 0.3f);
pad2 = (((1.0f / roData->unk_0C) * 0.7f) * (1.0f - camera->speedRatio));
@ -2120,12 +2139,12 @@ s32 Camera_Parallel1(Camera* camera) {
spA8.pitch = Camera_LERPCeilS(phi_a0, atToEyeNextDir.pitch, 1.0f / camera->pitchUpdateRateInv, 4);
if (spA8.pitch > OREG(5)) {
spA8.pitch = OREG(5);
if (spA8.pitch > R_CAM_MAX_PITCH) {
spA8.pitch = R_CAM_MAX_PITCH;
}
if (spA8.pitch < OREG(34)) {
spA8.pitch = OREG(34);
if (spA8.pitch < R_CAM_MIN_PITCH_1) {
spA8.pitch = R_CAM_MIN_PITCH_1;
}
}
Camera_Vec3fVecSphGeoAdd(eyeNext, at, &spA8);
@ -2201,8 +2220,8 @@ s32 Camera_Jump1(Camera* camera) {
playerHeight = Player_GetHeight(camera->player);
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->atYOffset = CAM_DATA_SCALED(GET_NEXT_RO_DATA(values)) * playerHeight * yNormal;
roData->distMin = CAM_DATA_SCALED(GET_NEXT_RO_DATA(values)) * playerHeight * yNormal;
@ -2243,14 +2262,15 @@ s32 Camera_Jump1(Camera* camera) {
if (rwData->swing.swingUpdateRateTimer != 0) {
camera->yawUpdateRateInv = Camera_LERPCeilF(roData->yawUpateRateTarget + rwData->swing.swingUpdateRateTimer,
camera->yawUpdateRateInv, CAM_DATA_SCALED(OREG(26)), 0.1f);
camera->pitchUpdateRateInv = Camera_LERPCeilF((f32)R_CAM_DEFA_PHI_UPDRATE + rwData->swing.swingUpdateRateTimer,
camera->pitchUpdateRateInv, CAM_DATA_SCALED(OREG(26)), 0.1f);
camera->pitchUpdateRateInv =
Camera_LERPCeilF((f32)R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV + rwData->swing.swingUpdateRateTimer,
camera->pitchUpdateRateInv, CAM_DATA_SCALED(OREG(26)), 0.1f);
rwData->swing.swingUpdateRateTimer--;
} else {
camera->yawUpdateRateInv =
Camera_LERPCeilF(roData->yawUpateRateTarget, camera->yawUpdateRateInv, CAM_DATA_SCALED(OREG(26)), 0.1f);
camera->pitchUpdateRateInv =
Camera_LERPCeilF((f32)R_CAM_DEFA_PHI_UPDRATE, camera->pitchUpdateRateInv, CAM_DATA_SCALED(OREG(26)), 0.1f);
camera->pitchUpdateRateInv = Camera_LERPCeilF((f32)R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV,
camera->pitchUpdateRateInv, CAM_DATA_SCALED(OREG(26)), 0.1f);
}
camera->xzOffsetUpdateRate =
@ -2285,11 +2305,11 @@ s32 Camera_Jump1(Camera* camera) {
eyeDiffSph.r = roData->distMax;
}
// Clamp the phi rotation at R_CAM_MAX_PHI AND R_CAM_MIN_PHI2
if (eyeDiffSph.pitch > R_CAM_MAX_PHI) {
eyeDiffSph.pitch = R_CAM_MAX_PHI;
} else if (eyeDiffSph.pitch < R_CAM_MIN_PHI2) {
eyeDiffSph.pitch = R_CAM_MIN_PHI2;
// Clamp the phi rotation at R_CAM_MAX_PITCH AND R_CAM_MIN_PITCH_2
if (eyeDiffSph.pitch > R_CAM_MAX_PITCH) {
eyeDiffSph.pitch = R_CAM_MAX_PITCH;
} else if (eyeDiffSph.pitch < R_CAM_MIN_PITCH_2) {
eyeDiffSph.pitch = R_CAM_MIN_PITCH_2;
}
Camera_Vec3fVecSphGeoAdd(&newEye, at, &eyeDiffSph);
@ -2356,7 +2376,8 @@ s32 Camera_Jump2(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
yNormal = (1.0f + CAM_DATA_SCALED(OREG(46))) - (CAM_DATA_SCALED(OREG(46)) * (68.0f / playerHeight));
yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->atYOffset =
CAM_DATA_SCALED((camera->playerPosDelta.y > 0.0f ? -10.0f : 10.0f) + GET_NEXT_RO_DATA(values)) *
playerHeight * yNormal;
@ -2396,7 +2417,7 @@ s32 Camera_Jump2(Camera* camera) {
}
yawDiff = (s16)(playerPosRot->rot.y - 0x7FFF) - atToEyeNextDir.yaw;
rwData->initYawDiff = ((yawDiff / OREG(23)) / 4) * 3;
rwData->initYawDiff = ((yawDiff / R_CAM_DEFAULT_ANIM_TIME) / 4) * 3;
if (roData->interfaceFlags & 2) {
rwData->yawAdj = 0xA;
} else {
@ -2406,7 +2427,7 @@ s32 Camera_Jump2(Camera* camera) {
playerPosRot->pos.x -= camera->playerPosDelta.x;
playerPosRot->pos.y -= camera->playerPosDelta.y;
playerPosRot->pos.z -= camera->playerPosDelta.z;
rwData->animTimer = OREG(23);
rwData->animTimer = R_CAM_DEFAULT_ANIM_TIME;
camera->animState++;
camera->atLERPStepScale = roData->atLERPStepScale;
}
@ -2560,8 +2581,8 @@ s32 Camera_Jump3(Camera* camera) {
if (RELOAD_PARAMS(camera) || modeSwitch || R_RELOAD_CAM_PARAMS) {
values = sCameraSettings[camera->setting].cameraModes[rwData->mode].values;
yNormal = ((1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight)));
yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
t2 = CAM_DATA_SCALED(playerHeight) * yNormal;
roData->yOffset = GET_NEXT_RO_DATA(values) * t2;
roData->distMin = GET_NEXT_RO_DATA(values) * t2;
@ -2660,12 +2681,12 @@ s32 Camera_Jump3(Camera* camera) {
eyeDiffSph.pitch = Camera_CalcDefaultPitch(camera, eyeNextAtOffset.pitch, roData->pitchTarget, 0);
}
if (eyeDiffSph.pitch > OREG(5)) {
eyeDiffSph.pitch = OREG(5);
if (eyeDiffSph.pitch > R_CAM_MAX_PITCH) {
eyeDiffSph.pitch = R_CAM_MAX_PITCH;
}
if (eyeDiffSph.pitch < OREG(34)) {
eyeDiffSph.pitch = OREG(34);
if (eyeDiffSph.pitch < R_CAM_MIN_PITCH_1) {
eyeDiffSph.pitch = R_CAM_MIN_PITCH_1;
}
Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeDiffSph);
@ -2751,7 +2772,8 @@ s32 Camera_Battle1(Camera* camera) {
playerHeight = Player_GetHeight(camera->player);
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(OREG(46))) - (CAM_DATA_SCALED(OREG(46)) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->distance = GET_NEXT_RO_DATA(values);
@ -2837,7 +2859,7 @@ s32 Camera_Battle1(Camera* camera) {
Camera_ChangeMode(camera, CAM_MODE_TARGET);
return true;
}
rwData->animTimer = OREG(23) + OREG(24);
rwData->animTimer = R_CAM_DEFAULT_ANIM_TIME + OREG(24);
rwData->initialEyeToAtYaw = atToEyeDir.yaw;
rwData->initialEyeToAtPitch = atToEyeDir.pitch;
rwData->initialEyeToAtDist = atToEyeDir.r;
@ -2894,7 +2916,7 @@ s32 Camera_Battle1(Camera* camera) {
OLib_Vec3fDiffToVecSphGeo(&playerToTargetDir, at, eye);
playerToTargetDir.yaw = tmpAng2 - 0x7FFF;
var2 = 1.0f / OREG(23);
var2 = 1.0f / R_CAM_DEFAULT_ANIM_TIME;
var3 = (rwData->initialEyeToAtDist - playerToTargetDir.r) * var2;
tmpAng1 = (s16)(rwData->initialEyeToAtYaw - playerToTargetDir.yaw) * var2;
tmpAng2 = (s16)(rwData->initialEyeToAtPitch - playerToTargetDir.pitch) * var2;
@ -2992,8 +3014,8 @@ s32 Camera_Battle4(Camera* camera) {
playerHeight = Player_GetHeight(camera->player);
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->rTarget = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
@ -3103,7 +3125,8 @@ s32 Camera_KeepOn1(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(OREG(46))) - (CAM_DATA_SCALED(OREG(46)) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->unk_00 = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->unk_04 = GET_NEXT_RO_DATA(values);
@ -3132,7 +3155,7 @@ s32 Camera_KeepOn1(Camera* camera) {
rwData->unk_10 = 0;
rwData->unk_04 = 0.0f;
rwData->unk_0C = camera->target;
rwData->unk_16 = OREG(23) + OREG(24);
rwData->unk_16 = R_CAM_DEFAULT_ANIM_TIME + OREG(24);
rwData->unk_12 = spC0.yaw;
rwData->unk_14 = spC0.pitch;
rwData->unk_00 = spC0.r;
@ -3225,7 +3248,7 @@ s32 Camera_KeepOn1(Camera* camera) {
OLib_Vec3fDiffToVecSphGeo(&spC8, at, eye);
spC8.yaw = spE2 - 0x7FFF;
t2 = 1.0f / OREG(23);
t2 = 1.0f / R_CAM_DEFAULT_ANIM_TIME;
spE8 = (rwData->unk_00 - spC8.r) * t2;
spE2 = (s16)(rwData->unk_12 - spC8.yaw) * t2;
spE0 = (s16)(rwData->unk_14 - spC8.pitch) * t2;
@ -3344,7 +3367,8 @@ s32 Camera_KeepOn3(Camera* camera) {
camera->unk_14C &= ~0x10;
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(OREG(46))) - (CAM_DATA_SCALED(OREG(46)) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->minDist = GET_NEXT_RO_DATA(values);
@ -3420,7 +3444,7 @@ s32 Camera_KeepOn3(Camera* camera) {
angleCnt = ARRAY_COUNT(D_8011D3B0);
i = 0;
targetToPlayerDir.r = prevTargetPlayerDist;
atToEyeAdj.r = ((roData->minDist + (targetToPlayerDir.r * (1 - 0.5f))) - atToEyeNextDir.r) + atToEyeNextDir.r;
atToEyeAdj.r = roData->minDist + (targetToPlayerDir.r * (1 - 0.5f)) - atToEyeNextDir.r + atToEyeNextDir.r;
Camera_Vec3fVecSphGeoAdd(&lineChkPointB, &rwData->atTarget, &atToEyeAdj);
if (!(roData->flags & 0x80)) {
while (i < angleCnt) {
@ -3537,7 +3561,7 @@ s32 Camera_KeepOn4(Camera* camera) {
camera->unk_14C &= ~0x10;
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + t) - ((68.0f / playerHeight) * t);
f32 yNormal = 1.0f + t - (68.0f / playerHeight * t);
roData->unk_00 = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->unk_04 = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
@ -3947,8 +3971,8 @@ s32 Camera_Fixed2(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = (GET_NEXT_SCALED_RO_DATA(values) * playerHeight) * yNormal;
roData->eyeStepScale = GET_NEXT_SCALED_RO_DATA(values);
@ -4035,7 +4059,7 @@ s32 Camera_Fixed3(Camera* camera) {
*eye = *eyeNext;
rwData->rot = bgCamFuncData->rot;
rwData->fov = bgCamFuncData->fov;
rwData->jfifId = bgCamFuncData->jfifId;
rwData->roomImageOverrideBgCamIndex = bgCamFuncData->roomImageOverrideBgCamIndex;
if (rwData->fov == -1) {
rwData->fov = 6000;
}
@ -4054,9 +4078,9 @@ s32 Camera_Fixed3(Camera* camera) {
camera->animState++;
}
if (bgCamFuncData->jfifId != rwData->jfifId) {
osSyncPrintf("camera: position change %d \n", rwData->jfifId);
rwData->jfifId = bgCamFuncData->jfifId;
if (bgCamFuncData->roomImageOverrideBgCamIndex != rwData->roomImageOverrideBgCamIndex) {
osSyncPrintf("camera: position change %d \n", rwData->roomImageOverrideBgCamIndex);
rwData->roomImageOverrideBgCamIndex = bgCamFuncData->roomImageOverrideBgCamIndex;
rwData->updDirTimer = 5;
}
@ -4104,7 +4128,8 @@ s32 Camera_Fixed4(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = ((1.0f + CAM_DATA_SCALED(OREG(46))) - (CAM_DATA_SCALED(OREG(46)) * (68.0f / playerYOffset)));
f32 yNormal = 1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerYOffset));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerYOffset * yNormal;
roData->speedToEyePos = GET_NEXT_SCALED_RO_DATA(values);
@ -4230,7 +4255,7 @@ s32 Camera_Subj3(Camera* camera) {
rwData->r = sp7C.r;
rwData->yaw = sp7C.yaw;
rwData->pitch = sp7C.pitch;
rwData->animTimer = OREG(23);
rwData->animTimer = R_CAM_DEFAULT_ANIM_TIME;
camera->dist = roData->eyeNextDist;
camera->animState++;
camera->rUpdateRateInv = 1.0f;
@ -4247,7 +4272,7 @@ s32 Camera_Subj3(Camera* camera) {
at->y = at->y + (sp98.y - pad2->y) * temp_f0_3;
at->z = at->z + (sp98.z - pad2->z) * temp_f0_3;
temp_f0_3 = (1.0f / OREG(23));
temp_f0_3 = (1.0f / R_CAM_DEFAULT_ANIM_TIME);
sp58 = (tsph.r - sp84.r) * temp_f0_3;
sp52 = (s16)(tsph.yaw - sp84.yaw) * temp_f0_3;
sp50 = (s16)(tsph.pitch - sp84.pitch) * temp_f0_3;
@ -4480,8 +4505,8 @@ s32 Camera_Data4(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
yNormal = (1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->fov = GET_NEXT_RO_DATA(values);
roData->interfaceFlags = GET_NEXT_RO_DATA(values);
@ -4556,8 +4581,8 @@ s32 Camera_Unique1(Camera* camera) {
playerHeight = Player_GetHeight(camera->player);
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->distMin = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
@ -4585,7 +4610,7 @@ s32 Camera_Unique1(Camera* camera) {
rwData->unk_00 = 0.0f;
playerWaistPos = camera->player->bodyPartsPos[PLAYER_BODYPART_WAIST];
OLib_Vec3fDiffToVecSphGeo(&unk908PlayerPosOffset, &playerPosRot->pos, &playerWaistPos);
rwData->timer = R_DEFA_CAM_ANIM_TIME;
rwData->timer = R_CAM_DEFAULT_ANIM_TIME;
rwData->yawTargetAdj = ABS((s16)(unk908PlayerPosOffset.yaw - eyeAtOffset.yaw)) < 0x3A98
? 0
: (((s16)(unk908PlayerPosOffset.yaw - eyeAtOffset.yaw) / rwData->timer) / 4) * 3;
@ -4608,11 +4633,11 @@ s32 Camera_Unique1(Camera* camera) {
phiTarget = roData->pitchTarget;
sp8C.pitch = Camera_LERPCeilS(phiTarget, eyeNextAtOffset.pitch, 1.0f / camera->pitchUpdateRateInv, 0xA);
if (sp8C.pitch > OREG(5)) {
sp8C.pitch = OREG(5);
if (sp8C.pitch > R_CAM_MAX_PITCH) {
sp8C.pitch = R_CAM_MAX_PITCH;
}
if (sp8C.pitch < -OREG(5)) {
sp8C.pitch = -OREG(5);
if (sp8C.pitch < -R_CAM_MAX_PITCH) {
sp8C.pitch = -R_CAM_MAX_PITCH;
}
if (rwData->timer != 0) {
@ -4650,8 +4675,8 @@ s32 Camera_Unique2(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = ((1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight)));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->distTarget = GET_NEXT_RO_DATA(values);
@ -4726,8 +4751,8 @@ s32 Camera_Unique3(Camera* camera) {
camera->unk_14C &= ~0x10;
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal = (1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) -
(CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
f32 yNormal =
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerHeight));
roData->yOffset = GET_NEXT_SCALED_RO_DATA(values) * playerHeight * yNormal;
roData->fov = GET_NEXT_RO_DATA(values);
@ -5617,7 +5642,7 @@ s32 Camera_Demo1(Camera* camera) {
switch (camera->animState) {
case 0:
// initalize camera state
// initialize camera state
rwData->keyframe = 0;
rwData->curFrame = 0.0f;
camera->animState++;
@ -6149,7 +6174,7 @@ s32 Camera_Demo6(Camera* camera) {
switch (camera->animState) {
case 0:
// initalizes the camera state.
// initializes the camera state.
rwData->animTimer = 0;
camera->fov = 60.0f;
Actor_GetWorld(&focusPosRot, camFocus);
@ -6255,7 +6280,7 @@ s32 Camera_Demo9(Camera* camera) {
switch (camera->animState) {
case 0:
// initalize the camera state
// initialize the camera state
rwData->keyframe = 0;
rwData->finishAction = 0;
rwData->curFrame = 0.0f;
@ -6276,7 +6301,7 @@ s32 Camera_Demo9(Camera* camera) {
// if the animation timer is still running, run the demo logic
// if it is not, then the case will fallthrough to the finish logic.
// Run the at and eye cs interpoloation functions, if either of them return 1 (that no more points
// Run the at and eye cs interpolation functions, if either of them returns 1 (that no more points
// exist) change the animation state to 2 (standby)
if (func_800BB2B4(&csEyeUpdate, &newRoll, camFOV, onePointCamData->eyePoints, &rwData->keyframe,
&rwData->curFrame) != 0 ||
@ -6478,7 +6503,7 @@ s32 Camera_Special5(Camera* camera) {
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
f32 yNormal =
(1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / yOffset));
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / yOffset));
roData->yOffset = (GET_NEXT_SCALED_RO_DATA(values) * yOffset) * yNormal;
roData->eyeDist = GET_NEXT_RO_DATA(values);
@ -6686,7 +6711,7 @@ s32 Camera_Special6(Camera* camera) {
camera->fov += (CAM_DATA_SCALED(fov) - camera->fov) / rwData->animTimer;
rwData->animTimer--;
} else {
// Camera following link on the x axis.
// Camera following player on the x axis.
sCameraInterfaceFlags &= 0xF0FF;
eyePosCalc = *eyeNext;
eyePosCalc.x += (playerPosRot->pos.x - eyePosCalc.x) * 0.5f;
@ -6730,7 +6755,7 @@ s32 Camera_Special9(Camera* camera) {
playerYOffset = Player_GetHeight(camera->player);
camera->unk_14C &= ~0x10;
yNormal =
(1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM)) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerYOffset));
1.0f + CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) - (CAM_DATA_SCALED(R_CAM_YOFFSET_NORM) * (68.0f / playerYOffset));
if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
@ -6930,7 +6955,7 @@ void Camera_Init(Camera* camera, View* view, CollisionContext* colCtx, PlayState
camera->up.y = 1.0f;
camera->up.z = 0.0f;
camera->fov = 60.0f;
camera->pitchUpdateRateInv = R_CAM_DEFA_PHI_UPDRATE;
camera->pitchUpdateRateInv = R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV;
camera->xzOffsetUpdateRate = CAM_DATA_SCALED(OREG(2));
camera->yOffsetUpdateRate = CAM_DATA_SCALED(OREG(3));
camera->fovUpdateRate = CAM_DATA_SCALED(OREG(4));
@ -6959,7 +6984,7 @@ void func_80057FC4(Camera* camera) {
if (camera != &camera->play->mainCamera) {
camera->prevSetting = camera->setting = CAM_SET_FREE0;
camera->unk_14C &= ~0x4;
} else if (camera->play->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_1) {
} else if (camera->play->roomCtx.curRoom.roomShape->base.type != ROOM_SHAPE_TYPE_IMAGE) {
switch (camera->play->roomCtx.curRoom.behaviorType1) {
case ROOM_BEHAVIOR_TYPE1_1:
Camera_ChangeDoorCam(camera, NULL, -99, 0, 0, 18, 10);

62
src/code/z_camera_data.c
View file

@ -27,12 +27,62 @@ typedef struct {
/*==================================================================*/
// Data
s16 sOREGInit[] = {
0, 1, 5, 5, 5, 14500, 20, 16, 150, 25, 150, 6, 10, 10, 0, 0, 1, 100,
250, 120, 80, 30, 120, 4, 1, 50, 20, 1800, 50, 50, 50, 20, 20, -10, -5460, -9100,
-6, 8, 15, 75, 60, 12, 110, 40, 50, 250, -10, 30, 30, 70, 20, 20, 20,
0, // OREG(0)
1, // OREG(1)
5, // OREG(2)
5, // OREG(3)
5, // OREG(4)
14500, // R_CAM_MAX_PITCH
20, // OREG(6)
16, // R_CAM_DEFAULT_PITCH_UPDATE_RATE_INV
150, // OREG(8)
25, // OREG(9)
150, // OREG(10)
6, // OREG(11)
10, // OREG(12)
10, // OREG(13)
0, // OREG(14)
0, // OREG(15)
1, // OREG(16)
100, // R_CAM_PITCH_FLOOR_CHECK_NEAR_DIST_FAC
250, // R_CAM_PITCH_FLOOR_CHECK_FAR_DIST_FAC
120, // R_CAM_PITCH_FLOOR_CHECK_OFFSET_Y_FAC
80, // R_CAM_PITCH_FLOOR_CHECK_NEAR_WEIGHT
30, // OREG(21)
120, // OREG(22)
4, // R_CAM_DEFAULT_ANIM_TIME
1, // OREG(24)
50, // OREG(25)
20, // OREG(26)
1800, // OREG(27)
50, // OREG(28)
50, // OREG(29)
50, // OREG(30)
20, // OREG(31)
20, // OREG(32)
-10, // OREG(33)
-5460, // R_CAM_MIN_PITCH_1
-9100, // R_CAM_MIN_PITCH_2
-6, // OREG(36)
8, // OREG(37)
15, // OREG(38)
75, // OREG(39)
60, // OREG(40)
12, // R_CAM_AT_LERP_STEP_SCALE_MIN
110, // R_CAM_AT_LERP_STEP_SCALE_FAC
40, // OREG(43)
50, // OREG(44)
250, // OREG(45)
-10, // R_CAM_YOFFSET_NORM
30, // OREG(47)
30, // OREG(48)
70, // OREG(49)
20, // OREG(50)
20, // OREG(51)
20, // OREG(52)
};
s16 sOREGInitCnt = 53;
s16 sOREGInitCnt = ARRAY_COUNT(sOREGInit);
s16 sCamDataRegsInit[CAM_DATA_MAX] = {
-20, // CAM_DATA_Y_OFFSET
@ -355,8 +405,8 @@ CameraModeValue sSetNormal3ModeTalkData[] = {
CAM_FUNCDATA_KEEP3(-30, 70, 200, 40, 10, 10, 20, 70, 45, 10, 10, 0x3500),
};
/* These values are for when the eye
* >= OREG(45) units below the surface of the water.
/*
* These values are for when the eye is >= OREG(45) units below the surface of the water.
*/
CameraModeValue sSetNormal3ModeBoomerangData[] = {
CAM_FUNCDATA_JUMP3(-40, 150, 250, -5, 18, 5, 60, 60, 40, 0x0005),

4
src/code/z_malloc.c
View file

@ -104,6 +104,6 @@ void ZeldaArena_Cleanup(void) {
__osMallocCleanup(&sZeldaArena);
}
u8 ZeldaArena_IsInitalized(void) {
return __osMallocIsInitalized(&sZeldaArena);
u8 ZeldaArena_IsInitialized(void) {
return __osMallocIsInitialized(&sZeldaArena);
}

8
src/code/z_play.c
View file

@ -517,10 +517,10 @@ void Play_Update(PlayState* this) {
// fade out bgm if "continue bgm" flag is not set
if (!(gEntranceTable[this->nextEntranceIndex + sceneLayer].field &
ENTRANCE_INFO_CONTINUE_BGM_FLAG)) {
// "Sound initalized. 111"
// "Sound initialized. 111"
osSyncPrintf("\n\n\nサウンドイニシャル来ました。111");
if ((this->transitionType < TRANS_TYPE_MAX) && !Environment_IsForcedSequenceDisabled()) {
// "Sound initalized. 222"
// "Sound initialized. 222"
osSyncPrintf("\n\n\nサウンドイニシャル来ました。222");
func_800F6964(0x14);
gSaveContext.seqId = (u8)NA_BGM_DISABLED;
@ -1740,8 +1740,8 @@ void Play_TriggerRespawn(PlayState* this) {
s32 Play_CamIsNotFixed(PlayState* this) {
// SCENE_CAM_TYPE_FIXED_SHOP_VIEWPOINT was probably intended to be in this condition,
// but the scene mesh header handles all shop cases regardless
return (this->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_1) &&
// but the room shape type check handles all shop cases regardless
return (this->roomCtx.curRoom.roomShape->base.type != ROOM_SHAPE_TYPE_IMAGE) &&
(R_SCENE_CAM_TYPE != SCENE_CAM_TYPE_FIXED_TOGGLE_VIEWPOINT) && (R_SCENE_CAM_TYPE != SCENE_CAM_TYPE_FIXED) &&
(R_SCENE_CAM_TYPE != SCENE_CAM_TYPE_FIXED_MARKET) && (this->sceneId != SCENE_HAIRAL_NIWA);
}

528
src/code/z_room.c
View file

@ -1,10 +1,6 @@
#include "global.h"
#include "vt.h"
void Room_Draw0(PlayState* play, Room* room, u32 flags);
void Room_Draw2(PlayState* play, Room* room, u32 flags);
void Room_Draw1(PlayState* play, Room* room, u32 flags);
Vec3f D_801270A0 = { 0.0f, 0.0f, 0.0f };
// unused
@ -22,19 +18,23 @@ Gfx D_801270B0[] = {
gsSPEndDisplayList(),
};
void (*sRoomDrawHandlers[MESH_HEADER_TYPE_MAX])(PlayState* play, Room* room, u32 flags) = {
Room_Draw0,
Room_Draw1,
Room_Draw2,
void Room_DrawNormal(PlayState* play, Room* room, u32 flags);
void Room_DrawImage(PlayState* play, Room* room, u32 flags);
void Room_DrawCullable(PlayState* play, Room* room, u32 flags);
void (*sRoomDrawHandlers[ROOM_SHAPE_TYPE_MAX])(PlayState* play, Room* room, u32 flags) = {
Room_DrawNormal, // ROOM_SHAPE_TYPE_NORMAL
Room_DrawImage, // ROOM_SHAPE_TYPE_IMAGE
Room_DrawCullable, // ROOM_SHAPE_TYPE_CULLABLE
};
void func_80095AA0(PlayState* play, Room* room, Input* arg2, UNK_TYPE arg3) {
void func_80095AA0(PlayState* play, Room* room, Input* input, s32 arg3) {
}
void Room_Draw0(PlayState* play, Room* room, u32 flags) {
void Room_DrawNormal(PlayState* play, Room* room, u32 flags) {
s32 i;
MeshHeader0* meshHeader0;
MeshHeader01Entry* meshHeader0Entry;
RoomShapeNormal* roomShape;
RoomShapeDListsEntry* entry;
OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 193);
@ -52,59 +52,75 @@ void Room_Draw0(PlayState* play, Room* room, u32 flags) {
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
}
meshHeader0 = &room->meshHeader->meshHeader0;
meshHeader0Entry = SEGMENTED_TO_VIRTUAL(meshHeader0->entries);
for (i = 0; i < meshHeader0->numEntries; i++) {
if ((flags & ROOM_DRAW_OPA) && (meshHeader0Entry->opa != NULL)) {
gSPDisplayList(POLY_OPA_DISP++, meshHeader0Entry->opa);
roomShape = &room->roomShape->normal;
entry = SEGMENTED_TO_VIRTUAL(roomShape->entries);
for (i = 0; i < roomShape->numEntries; i++) {
if ((flags & ROOM_DRAW_OPA) && (entry->opa != NULL)) {
gSPDisplayList(POLY_OPA_DISP++, entry->opa);
}
if ((flags & ROOM_DRAW_XLU) && (meshHeader0Entry->xlu != NULL)) {
gSPDisplayList(POLY_XLU_DISP++, meshHeader0Entry->xlu);
if ((flags & ROOM_DRAW_XLU) && (entry->xlu != NULL)) {
gSPDisplayList(POLY_XLU_DISP++, entry->xlu);
}
meshHeader0Entry++;
entry++;
}
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 239);
}
#define SHAPE_SORT_MAX 64
typedef enum {
/* 0 */ ROOM_CULL_DEBUG_MODE_OFF,
/* 1 */ ROOM_CULL_DEBUG_MODE_UP_TO_TARGET,
/* 2 */ ROOM_CULL_DEBUG_MODE_ONLY_TARGET
} RoomCullableDebugMode;
typedef struct struct_80095D04 {
/* 0x00 */ MeshHeader2Entry* unk_00;
/* 0x04 */ f32 unk_04;
/* 0x08 */ struct struct_80095D04* unk_08;
/* 0x0C */ struct struct_80095D04* unk_0C;
} struct_80095D04; // size = 0x10
typedef struct RoomShapeCullableEntryLinked {
/* 0x00 */ RoomShapeCullableEntry* entry;
/* 0x04 */ f32 boundsNearZ;
/* 0x08 */ struct RoomShapeCullableEntryLinked* prev;
/* 0x0C */ struct RoomShapeCullableEntryLinked* next;
} RoomShapeCullableEntryLinked; // size = 0x10
void Room_Draw2(PlayState* play, Room* room, u32 flags) {
MeshHeader2* meshHeader2;
MeshHeader2Entry* meshHeader2Entry;
struct_80095D04 spB8[SHAPE_SORT_MAX];
struct_80095D04* spB4 = NULL;
struct_80095D04* spB0 = NULL;
struct_80095D04* iter;
/**
* Handle room drawing for the "cullable" type of room shape.
*
* Each entry referenced by the room shape struct is attached to display lists, and a position and radius indicating the
* bounding sphere for the geometry drawn.
* The first step Z-sorts the entries, and excludes the entries with a bounding sphere that is entirely before or
* beyond the rendered depth range.
* The second step draws the entries that remain, from nearest to furthest.
*/
void Room_DrawCullable(PlayState* play, Room* room, u32 flags) {
RoomShapeCullable* roomShape;
RoomShapeCullableEntry* roomShapeCullableEntry;
RoomShapeCullableEntryLinked linkedEntriesBuffer[ROOM_SHAPE_CULLABLE_MAX_ENTRIES];
RoomShapeCullableEntryLinked* head = NULL;
RoomShapeCullableEntryLinked* tail = NULL;
RoomShapeCullableEntryLinked* iter;
s32 pad;
struct_80095D04* spA4;
RoomShapeCullableEntryLinked* insert;
s32 j;
s32 i;
Vec3f pos;
Vec3f projectedPos;
f32 projectedW;
s32 pad2;
MeshHeader2Entry* meshHeader2Entries;
MeshHeader2Entry* meshHeader2EntryIter;
f32 temp_f2;
RoomShapeCullableEntry* roomShapeCullableEntries;
RoomShapeCullableEntry* roomShapeCullableEntryIter;
f32 entryBoundsNearZ;
OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 287);
if (flags & ROOM_DRAW_OPA) {
func_800342EC(&D_801270A0, play);
gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
func_80093C80(play);
gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
}
if (1) {}
if (flags & ROOM_DRAW_XLU) {
func_8003435C(&D_801270A0, play);
gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
@ -112,80 +128,103 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
}
meshHeader2 = &room->meshHeader->meshHeader2;
meshHeader2Entry = SEGMENTED_TO_VIRTUAL(meshHeader2->entries);
spA4 = spB8;
roomShape = &room->roomShape->cullable;
roomShapeCullableEntry = SEGMENTED_TO_VIRTUAL(roomShape->entries);
insert = linkedEntriesBuffer;
ASSERT(meshHeader2->numEntries <= SHAPE_SORT_MAX, "polygon2->num <= SHAPE_SORT_MAX", "../z_room.c", 317);
meshHeader2Entries = meshHeader2Entry;
ASSERT(roomShape->numEntries <= ROOM_SHAPE_CULLABLE_MAX_ENTRIES, "polygon2->num <= SHAPE_SORT_MAX", "../z_room.c",
317);
for (i = 0; i < meshHeader2->numEntries; i++, meshHeader2Entry++) {
pos.x = meshHeader2Entry->pos.x;
pos.y = meshHeader2Entry->pos.y;
pos.z = meshHeader2Entry->pos.z;
roomShapeCullableEntries = roomShapeCullableEntry;
// Pick and sort entries by depth
for (i = 0; i < roomShape->numEntries; i++, roomShapeCullableEntry++) {
// Project the entry position, to get the depth it is at.
pos.x = roomShapeCullableEntry->boundsSphereCenter.x;
pos.y = roomShapeCullableEntry->boundsSphereCenter.y;
pos.z = roomShapeCullableEntry->boundsSphereCenter.z;
SkinMatrix_Vec3fMtxFMultXYZW(&play->viewProjectionMtxF, &pos, &projectedPos, &projectedW);
if (-(f32)meshHeader2Entry->unk_06 < projectedPos.z) {
temp_f2 = projectedPos.z - meshHeader2Entry->unk_06;
if (temp_f2 < play->lightCtx.fogFar) {
spA4->unk_00 = meshHeader2Entry;
spA4->unk_04 = temp_f2;
iter = spB4;
// If the entry bounding sphere isn't fully before the rendered depth range
if (-(f32)roomShapeCullableEntry->boundsSphereRadius < projectedPos.z) {
// Compute the depth of the nearest point in the entry's bounding sphere
entryBoundsNearZ = projectedPos.z - roomShapeCullableEntry->boundsSphereRadius;
// If the entry bounding sphere isn't fully beyond the rendered depth range
if (entryBoundsNearZ < play->lightCtx.fogFar) {
// This entry will be rendered
insert->entry = roomShapeCullableEntry;
insert->boundsNearZ = entryBoundsNearZ;
// Insert into the linked list, ordered by ascending depth of the nearest point in the bounding sphere
iter = head;
if (iter == NULL) {
spB4 = spB0 = spA4;
spA4->unk_08 = spA4->unk_0C = NULL;
head = tail = insert;
insert->prev = insert->next = NULL;
} else {
do {
if (spA4->unk_04 < iter->unk_04) {
if (insert->boundsNearZ < iter->boundsNearZ) {
break;
}
iter = iter->unk_0C;
iter = iter->next;
} while (iter != NULL);
if (iter == NULL) {
spA4->unk_08 = spB0;
spA4->unk_0C = NULL;
spB0->unk_0C = spA4;
spB0 = spA4;
insert->prev = tail;
insert->next = NULL;
tail->next = insert;
tail = insert;
} else {
spA4->unk_08 = iter->unk_08;
if (spA4->unk_08 == NULL) {
spB4 = spA4;
insert->prev = iter->prev;
if (insert->prev == NULL) {
head = insert;
} else {
spA4->unk_08->unk_0C = spA4;
insert->prev->next = insert;
}
iter->unk_08 = spA4;
spA4->unk_0C = iter;
iter->prev = insert;
insert->next = iter;
}
}
spA4++;
insert++;
}
}
}
iREG(87) = meshHeader2->numEntries & 0xFFFF & 0xFFFF & 0xFFFF; // if this is real then I might not be
// if this is real then I might not be
R_ROOM_CULL_NUM_ENTRIES = roomShape->numEntries & 0xFFFF & 0xFFFF & 0xFFFF;
for (i = 1; spB4 != NULL; spB4 = spB4->unk_0C, i++) {
// Draw entries, from nearest to furthest
for (i = 1; head != NULL; head = head->next, i++) {
Gfx* displayList;
meshHeader2Entry = spB4->unk_00;
if (iREG(86) != 0) {
meshHeader2EntryIter = meshHeader2Entries;
for (j = 0; j < meshHeader2->numEntries; j++, meshHeader2EntryIter++) {
if (meshHeader2Entry == meshHeader2EntryIter) {
break; // This loop does nothing?
roomShapeCullableEntry = head->entry;
if (R_ROOM_CULL_DEBUG_MODE != ROOM_CULL_DEBUG_MODE_OFF) {
// Debug mode drawing
// This loop does nothing
roomShapeCullableEntryIter = roomShapeCullableEntries;
for (j = 0; j < roomShape->numEntries; j++, roomShapeCullableEntryIter++) {
if (roomShapeCullableEntry == roomShapeCullableEntryIter) {
break;
}
}
if (((iREG(86) == 1) && (iREG(89) >= i)) || ((iREG(86) == 2) && (iREG(89) == i))) {
if (((R_ROOM_CULL_DEBUG_MODE == ROOM_CULL_DEBUG_MODE_UP_TO_TARGET) && (i <= R_ROOM_CULL_DEBUG_TARGET)) ||
((R_ROOM_CULL_DEBUG_MODE == ROOM_CULL_DEBUG_MODE_ONLY_TARGET) && (i == R_ROOM_CULL_DEBUG_TARGET))) {
if (flags & ROOM_DRAW_OPA) {
displayList = meshHeader2Entry->opa;
displayList = roomShapeCullableEntry->opa;
if (displayList != NULL) {
gSPDisplayList(POLY_OPA_DISP++, displayList);
}
}
if (flags & ROOM_DRAW_XLU) {
displayList = meshHeader2Entry->xlu;
displayList = roomShapeCullableEntry->xlu;
if (displayList != NULL) {
gSPDisplayList(POLY_XLU_DISP++, displayList);
}
@ -193,14 +232,14 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
}
} else {
if (flags & ROOM_DRAW_OPA) {
displayList = meshHeader2Entry->opa;
displayList = roomShapeCullableEntry->opa;
if (displayList != NULL) {
gSPDisplayList(POLY_OPA_DISP++, displayList);
}
}
if (flags & ROOM_DRAW_XLU) {
displayList = meshHeader2Entry->xlu;
displayList = roomShapeCullableEntry->xlu;
if (displayList != NULL) {
gSPDisplayList(POLY_XLU_DISP++, displayList);
}
@ -208,14 +247,18 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
}
}
iREG(88) = i - 1;
R_ROOM_CULL_USED_ENTRIES = i - 1;
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 430);
}
#define JPEG_MARKER 0xFFD8FFE0
s32 func_80096238(void* data) {
/**
* If the data is JPEG, decode it and overwrite the initial data with the result.
* Uses the depth frame buffer as temporary storage.
*/
s32 Room_DecodeJpeg(void* data) {
OSTime time;
if (*(u32*)data == JPEG_MARKER) {
@ -232,10 +275,10 @@ s32 func_80096238(void* data) {
osSyncPrintf("成功…だと思う。 time = %6.3f ms \n", OS_CYCLES_TO_USEC(time) / 1000.0f);
// "Writing back to original address from work buffer."
osSyncPrintf("ワークバッファから元のアドレスに書き戻します。\n");
// "If the original buffer size isn't at least 150kb, it will be out of control."
// "If the original buffer size isn't at least 150kB, it will be out of control."
osSyncPrintf("元のバッファのサイズが150キロバイト無いと暴走するでしょう。\n");
bcopy(gZBuffer, data, sizeof(gZBuffer));
bcopy(gZBuffer, data, sizeof(u16[SCREEN_HEIGHT][SCREEN_WIDTH]));
} else {
osSyncPrintf("失敗！なんで〜\n"); // "Failure! Why is it 〜"
}
@ -244,72 +287,78 @@ s32 func_80096238(void* data) {
return 0;
}
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) {
Gfx* displayListHead;
void Room_DrawBackground2D(Gfx** gfxP, void* tex, void* tlut, u16 width, u16 height, u8 fmt, u8 siz, u16 tlutMode,
u16 tlutCount, f32 offsetX, f32 offsetY) {
Gfx* gfx = *gfxP;
uObjBg* bg;
displayListHead = *displayList;
func_80096238(SEGMENTED_TO_VIRTUAL(source));
Room_DecodeJpeg(SEGMENTED_TO_VIRTUAL(tex));
bg = (uObjBg*)(gfx + 1);
gSPBranchList(gfx, (u32)bg + sizeof(uObjBg));
bg = (uObjBg*)(displayListHead + 1);
gSPBranchList(displayListHead, (u8*)bg + sizeof(uObjBg));
bg->b.imageX = 0;
bg->b.imageW = width * 4;
bg->b.frameX = frameX * 4;
bg->b.imageW = width * (1 << 2);
bg->b.frameX = offsetX * (1 << 2);
bg->b.imageY = 0;
bg->b.imageH = height * 4;
bg->b.frameY = frameY * 4;
bg->b.imagePtr = source;
bg->b.imageH = height * (1 << 2);
bg->b.frameY = offsetY * (1 << 2);
bg->b.imagePtr = tex;
bg->b.imageLoad = G_BGLT_LOADTILE;
bg->b.imageFmt = fmt;
bg->b.imageSiz = siz;
bg->b.imagePal = 0;
bg->b.imageFlip = 0;
displayListHead = (void*)(bg + 1);
gfx = (Gfx*)((u32)bg + sizeof(uObjBg));
if (fmt == G_IM_FMT_CI) {
gDPLoadTLUT(displayListHead++, tlutCount, 256, tlut);
gDPLoadTLUT(gfx++, tlutCount, 256, tlut);
} else {
gDPPipeSync(displayListHead++);
gDPPipeSync(gfx++);
}
if ((fmt == G_IM_FMT_RGBA) && (SREG(26) == 0)) {
bg->b.frameW = width * 4;
bg->b.frameH = height * 4;
if ((fmt == G_IM_FMT_RGBA) && !R_ROOM_BG2D_FORCE_SCALEBG) {
bg->b.frameW = width * (1 << 2);
bg->b.frameH = height * (1 << 2);
guS2DInitBg(bg);
gDPSetOtherMode(displayListHead++, mode0 | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
gDPSetOtherMode(gfx++, tlutMode | G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
G_AC_THRESHOLD | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2);
gSPBgRectCopy(displayListHead++, bg);
gSPBgRectCopy(gfx++, bg);
} else {
bg->s.frameW = width * 4;
bg->s.frameH = height * 4;
bg->s.scaleW = 1024;
bg->s.scaleH = 1024;
bg->s.frameW = width * (1 << 2);
bg->s.frameH = height * (1 << 2);
bg->s.scaleW = 1 << 10;
bg->s.scaleH = 1 << 10;
bg->s.imageYorig = bg->b.imageY;
gDPSetOtherMode(displayListHead++,
mode0 | G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE |
G_TL_TILE | G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
gDPSetOtherMode(gfx++,
tlutMode | G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
G_AC_THRESHOLD | G_ZS_PIXEL | AA_EN | CVG_DST_CLAMP | ZMODE_OPA | CVG_X_ALPHA | ALPHA_CVG_SEL |
GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_BL, G_BL_1MA) |
GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_BL, G_BL_1MA));
gDPSetCombineLERP(displayListHead++, 0, 0, 0, TEXEL0, 0, 0, 0, 1, 0, 0, 0, TEXEL0, 0, 0, 0, 1);
gSPObjRenderMode(displayListHead++, G_OBJRM_ANTIALIAS | G_OBJRM_BILERP);
gSPBgRect1Cyc(displayListHead++, bg);
gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 0, 0, 0, 1, 0, 0, 0, TEXEL0, 0, 0, 0, 1);
gSPObjRenderMode(gfx++, G_OBJRM_ANTIALIAS | G_OBJRM_BILERP);
gSPBgRect1Cyc(gfx++, bg);
}
gDPPipeSync(displayListHead++);
*displayList = displayListHead;
gDPPipeSync(gfx++);
*gfxP = gfx;
}
void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
#define ROOM_IMAGE_NODRAW_BACKGROUND (1 << 0)
#define ROOM_IMAGE_NODRAW_OPA (1 << 1)
#define ROOM_IMAGE_NODRAW_XLU (1 << 2)
void Room_DrawImageSingle(PlayState* play, Room* room, u32 flags) {
Camera* activeCam;
Gfx* spA8;
MeshHeader1Single* meshHeader1Single;
MeshHeader01Entry* meshHeader1Entry;
Gfx* gfx;
RoomShapeImageSingle* roomShape;
RoomShapeDListsEntry* entry;
u32 isFixedCamera;
u32 drawBg;
u32 drawBackground;
u32 drawOpa;
u32 drawXlu;
@ -317,123 +366,34 @@ void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
activeCam = GET_ACTIVE_CAM(play);
isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
meshHeader1Single = &room->meshHeader->meshHeader1Single;
meshHeader1Entry = SEGMENTED_TO_VIRTUAL(meshHeader1Single->base.entry);
drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && meshHeader1Single->source && !(SREG(25) & 1);
drawOpa = (flags & ROOM_DRAW_OPA) && (meshHeader1Entry->opa != NULL) && !(SREG(25) & 2);
drawXlu = (flags & ROOM_DRAW_XLU) && (meshHeader1Entry->xlu != NULL) && !(SREG(25) & 4);
roomShape = &room->roomShape->image.single;
entry = SEGMENTED_TO_VIRTUAL(roomShape->base.entry);
drawBackground = (flags & ROOM_DRAW_OPA) && isFixedCamera && (roomShape->source != NULL) &&
!(R_ROOM_IMAGE_NODRAW_FLAGS & ROOM_IMAGE_NODRAW_BACKGROUND);
drawOpa = (flags & ROOM_DRAW_OPA) && (entry->opa != NULL) && !(R_ROOM_IMAGE_NODRAW_FLAGS & ROOM_IMAGE_NODRAW_OPA);
drawXlu = (flags & ROOM_DRAW_XLU) && (entry->xlu != NULL) && !(R_ROOM_IMAGE_NODRAW_FLAGS & ROOM_IMAGE_NODRAW_XLU);
if (drawOpa || drawBg) {
if (drawOpa || drawBackground) {
gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
if (drawOpa) {
Gfx_SetupDL_25Opa(play->state.gfxCtx);
gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_OPA_DISP++, meshHeader1Entry->opa);
gSPDisplayList(POLY_OPA_DISP++, entry->opa);
}
if (drawBg) {
if (drawBackground) {
gSPLoadUcodeL(POLY_OPA_DISP++, gspS2DEX2d_fifo);
{
Vec3f sp60;
spA8 = POLY_OPA_DISP;
Camera_GetSkyboxOffset(&sp60, activeCam);
func_8009638C(&spA8, meshHeader1Single->source, meshHeader1Single->tlut, meshHeader1Single->width,
meshHeader1Single->height, meshHeader1Single->fmt, meshHeader1Single->siz,
meshHeader1Single->mode0, meshHeader1Single->tlutCount,
(sp60.x + sp60.z) * 1.2f + sp60.y * 0.6f, sp60.y * 2.4f + (sp60.x + sp60.z) * 0.3f);
POLY_OPA_DISP = spA8;
}
gSPLoadUcode(POLY_OPA_DISP++, SysUcode_GetUCode(), SysUcode_GetUCodeData());
}
}
if (drawXlu) {
gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
Gfx_SetupDL_25Xlu(play->state.gfxCtx);
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_XLU_DISP++, meshHeader1Entry->xlu);
}
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 691);
}
BgImage* func_80096A74(MeshHeader1Multi* meshHeader1Multi, PlayState* play) {
Camera* activeCam = GET_ACTIVE_CAM(play);
s32 bgCamIndex = activeCam->bgCamIndex;
s16 jfifId;
Player* player;
BgImage* bgImage;
s32 i;
jfifId = ((BgCamFuncData*)BgCheck_GetBgCamFuncDataImpl(&play->colCtx, bgCamIndex, BGCHECK_SCENE))->jfifId;
if (jfifId >= 0) {
bgCamIndex = jfifId;
}
player = GET_PLAYER(play);
player->actor.params = (player->actor.params & 0xFF00) | bgCamIndex;
bgImage = SEGMENTED_TO_VIRTUAL(meshHeader1Multi->list);
for (i = 0; i < meshHeader1Multi->count; i++) {
if (bgImage->id == bgCamIndex) {
return bgImage;
}
bgImage++;
}
// "z_room.c: Data consistent with camera id does not exist camid=%d"
osSyncPrintf(VT_COL(RED, WHITE) "z_room.c:カメラＩＤに一致するデータが存在しません camid=%d\n" VT_RST, bgCamIndex);
LogUtils_HungupThread("../z_room.c", 726);
return NULL;
}
void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) {
Camera* activeCam;
Gfx* gfx;
MeshHeader1Multi* meshHeader1Multi;
BgImage* bgImage;
MeshHeader01Entry* meshHeader1Entry;
u32 isFixedCamera;
u32 drawBg;
u32 drawOpa;
u32 drawXlu;
OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 752);
activeCam = GET_ACTIVE_CAM(play);
isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
meshHeader1Multi = &room->meshHeader->meshHeader1Multi;
meshHeader1Entry = SEGMENTED_TO_VIRTUAL(meshHeader1Multi->base.entry);
bgImage = func_80096A74(meshHeader1Multi, play);
drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && bgImage->source && !(SREG(25) & 1);
drawOpa = (flags & ROOM_DRAW_OPA) && (meshHeader1Entry->opa != NULL) && !(SREG(25) & 2);
drawXlu = (flags & ROOM_DRAW_XLU) && (meshHeader1Entry->xlu != NULL) && !(SREG(25) & 4);
if (drawOpa || drawBg) {
gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
if (drawOpa) {
Gfx_SetupDL_25Opa(play->state.gfxCtx);
gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_OPA_DISP++, meshHeader1Entry->opa);
}
if (drawBg) {
gSPLoadUcodeL(POLY_OPA_DISP++, gspS2DEX2d_fifo);
{
Vec3f skyboxOffset;
Vec3f quakeOffset;
gfx = POLY_OPA_DISP;
Camera_GetSkyboxOffset(&skyboxOffset, activeCam);
func_8009638C(&gfx, bgImage->source, bgImage->tlut, bgImage->width, bgImage->height, bgImage->fmt,
bgImage->siz, bgImage->mode0, bgImage->tlutCount,
(skyboxOffset.x + skyboxOffset.z) * 1.2f + skyboxOffset.y * 0.6f,
skyboxOffset.y * 2.4f + (skyboxOffset.x + skyboxOffset.z) * 0.3f);
Camera_GetSkyboxOffset(&quakeOffset, activeCam);
Room_DrawBackground2D(&gfx, roomShape->source, roomShape->tlut, roomShape->width, roomShape->height,
roomShape->fmt, roomShape->siz, roomShape->tlutMode, roomShape->tlutCount,
(quakeOffset.x + quakeOffset.z) * 1.2f + quakeOffset.y * 0.6f,
quakeOffset.y * 2.4f + (quakeOffset.x + quakeOffset.z) * 0.3f);
POLY_OPA_DISP = gfx;
}
@ -445,19 +405,117 @@ void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) {
gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
Gfx_SetupDL_25Xlu(play->state.gfxCtx);
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_XLU_DISP++, meshHeader1Entry->xlu);
gSPDisplayList(POLY_XLU_DISP++, entry->xlu);
}
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 691);
}
RoomShapeImageMultiBgEntry* Room_GetImageMultiBgEntry(RoomShapeImageMulti* roomShapeImageMulti, PlayState* play) {
Camera* activeCam = GET_ACTIVE_CAM(play);
s32 bgCamIndex = activeCam->bgCamIndex;
s16 overrideBgCamIndex;
Player* player;
RoomShapeImageMultiBgEntry* bgEntry;
s32 i;
// In mq debug vanilla scenes, overrideBgCamIndex is always -1 or the same as bgCamIndex
overrideBgCamIndex = ((BgCamFuncData*)BgCheck_GetBgCamFuncDataImpl(&play->colCtx, bgCamIndex, BGCHECK_SCENE))
->roomImageOverrideBgCamIndex;
if (overrideBgCamIndex >= 0) {
bgCamIndex = overrideBgCamIndex;
}
player = GET_PLAYER(play);
player->actor.params = (player->actor.params & 0xFF00) | bgCamIndex;
bgEntry = SEGMENTED_TO_VIRTUAL(roomShapeImageMulti->backgrounds);
for (i = 0; i < roomShapeImageMulti->numBackgrounds; i++) {
if (bgEntry->bgCamIndex == bgCamIndex) {
return bgEntry;
}
bgEntry++;
}
// "z_room.c: Data consistent with camera id does not exist camid=%d"
osSyncPrintf(VT_COL(RED, WHITE) "z_room.c:カメラＩＤに一致するデータが存在しません camid=%d\n" VT_RST, bgCamIndex);
LogUtils_HungupThread("../z_room.c", 726);
return NULL;
}
void Room_DrawImageMulti(PlayState* play, Room* room, u32 flags) {
Camera* activeCam;
Gfx* gfx;
RoomShapeImageMulti* roomShape;
RoomShapeImageMultiBgEntry* bgEntry;
RoomShapeDListsEntry* dListsEntry;
u32 isFixedCamera;
u32 drawBackground;
u32 drawOpa;
u32 drawXlu;
OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 752);
activeCam = GET_ACTIVE_CAM(play);
isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
roomShape = &room->roomShape->image.multi;
dListsEntry = SEGMENTED_TO_VIRTUAL(roomShape->base.entry);
bgEntry = Room_GetImageMultiBgEntry(roomShape, play);
drawBackground = (flags & ROOM_DRAW_OPA) && isFixedCamera && (bgEntry->source != NULL) &&
!(R_ROOM_IMAGE_NODRAW_FLAGS & ROOM_IMAGE_NODRAW_BACKGROUND);
drawOpa =
(flags & ROOM_DRAW_OPA) && (dListsEntry->opa != NULL) && !(R_ROOM_IMAGE_NODRAW_FLAGS & ROOM_IMAGE_NODRAW_OPA);
drawXlu =
(flags & ROOM_DRAW_XLU) && (dListsEntry->xlu != NULL) && !(R_ROOM_IMAGE_NODRAW_FLAGS & ROOM_IMAGE_NODRAW_XLU);
if (drawOpa || drawBackground) {
gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
if (drawOpa) {
Gfx_SetupDL_25Opa(play->state.gfxCtx);
gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_OPA_DISP++, dListsEntry->opa);
}
if (drawBackground) {
gSPLoadUcodeL(POLY_OPA_DISP++, gspS2DEX2d_fifo);
{
Vec3f quakeOffset;
gfx = POLY_OPA_DISP;
Camera_GetSkyboxOffset(&quakeOffset, activeCam);
Room_DrawBackground2D(&gfx, bgEntry->source, bgEntry->tlut, bgEntry->width, bgEntry->height,
bgEntry->fmt, bgEntry->siz, bgEntry->tlutMode, bgEntry->tlutCount,
(quakeOffset.x + quakeOffset.z) * 1.2f + quakeOffset.y * 0.6f,
quakeOffset.y * 2.4f + (quakeOffset.x + quakeOffset.z) * 0.3f);
POLY_OPA_DISP = gfx;
}
gSPLoadUcode(POLY_OPA_DISP++, SysUcode_GetUCode(), SysUcode_GetUCodeData());
}
}
if (drawXlu) {
gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
Gfx_SetupDL_25Xlu(play->state.gfxCtx);
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_XLU_DISP++, dListsEntry->xlu);
}
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 819);
}
void Room_Draw1(PlayState* play, Room* room, u32 flags) {
MeshHeader1Base* meshHeader1Base = &room->meshHeader->meshHeader1Base;
void Room_DrawImage(PlayState* play, Room* room, u32 flags) {
RoomShapeImageBase* roomShape = &room->roomShape->image.base;
if (meshHeader1Base->format == MESH_HEADER1_FORMAT_SINGLE) {
Room_Draw1Single(play, room, flags);
} else if (meshHeader1Base->format == MESH_HEADER1_FORMAT_MULTI) {
Room_Draw1Multi(play, room, flags);
if (roomShape->amountType == ROOM_SHAPE_IMAGE_AMOUNT_SINGLE) {
Room_DrawImageSingle(play, room, flags);
} else if (roomShape->amountType == ROOM_SHAPE_IMAGE_AMOUNT_MULTI) {
Room_DrawImageMulti(play, room, flags);
} else {
LogUtils_HungupThread("../z_room.c", 841);
}
@ -578,9 +636,9 @@ s32 func_800973FC(PlayState* play, RoomContext* roomCtx) {
void Room_Draw(PlayState* play, Room* room, u32 flags) {
if (room->segment != NULL) {
gSegments[3] = VIRTUAL_TO_PHYSICAL(room->segment);
ASSERT(room->meshHeader->base.type < ARRAY_COUNTU(sRoomDrawHandlers),
ASSERT(room->roomShape->base.type < ARRAY_COUNTU(sRoomDrawHandlers),
"this->ground_shape->polygon.type < number(Room_Draw_Proc)", "../z_room.c", 1125);
sRoomDrawHandlers[room->meshHeader->base.type](play, room, flags);
sRoomDrawHandlers[room->roomShape->base.type](play, room, flags);
}
}

6
src/code/z_scene.c
View file

@ -243,8 +243,8 @@ void Scene_CommandRoomBehavior(PlayState* play, SceneCmd* cmd) {
play->msgCtx.disableWarpSongs = (cmd->roomBehavior.gpFlag2 >> 0xA) & 1;
}
void Scene_CommandMeshHeader(PlayState* play, SceneCmd* cmd) {
play->roomCtx.curRoom.meshHeader = SEGMENTED_TO_VIRTUAL(cmd->mesh.data);
void Scene_CommandRoomShape(PlayState* play, SceneCmd* cmd) {
play->roomCtx.curRoom.roomShape = SEGMENTED_TO_VIRTUAL(cmd->mesh.data);
}
void Scene_CommandObjectList(PlayState* play, SceneCmd* cmd) {
@ -480,7 +480,7 @@ void (*gSceneCmdHandlers[SCENE_CMD_ID_MAX])(PlayState*, SceneCmd*) = {
Scene_CommandSpecialFiles, // SCENE_CMD_ID_SPECIAL_FILES
Scene_CommandRoomBehavior, // SCENE_CMD_ID_ROOM_BEHAVIOR
Scene_CommandUndefined9, // SCENE_CMD_ID_UNDEFINED_9
Scene_CommandMeshHeader, // SCENE_CMD_ID_MESH_HEADER
Scene_CommandRoomShape, // SCENE_CMD_ID_ROOM_SHAPE
Scene_CommandObjectList, // SCENE_CMD_ID_OBJECT_LIST
Scene_CommandLightList, // SCENE_CMD_ID_LIGHT_LIST
Scene_CommandPathList, // SCENE_CMD_ID_PATH_LIST

4
src/code/z_view.c
View file

@ -334,7 +334,7 @@ s32 View_ApplyPerspective(View* view) {
Matrix_MtxToMtxF(projection, &mf);
osSyncPrintf("projection\n");
for (i = 0; i < 4; i++) {
osSyncPrintf(" %f %f %f %f\n", mf.mf[i][0], mf.mf[i][1], mf.mf[i][2], mf.mf[i][3]);
osSyncPrintf("\t%f\t%f\t%f\t%f\n", mf.mf[i][0], mf.mf[i][1], mf.mf[i][2], mf.mf[i][3]);
}
osSyncPrintf("\n");
}
@ -373,7 +373,7 @@ s32 View_ApplyPerspective(View* view) {
Matrix_MtxToMtxF(view->viewingPtr, &mf);
osSyncPrintf("viewing\n");
for (i = 0; i < 4; i++) {
osSyncPrintf(" %f %f %f %f\n", mf.mf[i][0], mf.mf[i][1], mf.mf[i][2], mf.mf[i][3]);
osSyncPrintf("\t%f\t%f\t%f\t%f\n", mf.mf[i][0], mf.mf[i][1], mf.mf[i][2], mf.mf[i][3]);
}
osSyncPrintf("\n");
}