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

Quake Documentation Pass (#1402)

Browse source 
* begin quake docs

* continue cleanup

* quake offset

* many more docs

* cleanup

* more cleanup

* cleanup headers

* move quake value to internal

* update, still need to test shake zoom/yaw

* more docs

* better docs

* add file descriptions

* fix comment

* explain random index

* cleanup comments

* better type 6 docs

* expand orientation comment

* fix old names, add comment

* remove comment, twas a mistake

* easy PR feedback

* duration in dec

* rm offset, clear up roll

* oops

* merge shakeInfo and QuakeCamData

* match order that always appears in code

* more PR suggestions

* adjust comment

* zeroVec

* rm extra space

* roman PR suggestions
This commit is contained in:
engineer124 2022-10-15 02:16:37 -04:00 • committed by GitHub
parent d1d946a197
commit 9675051377
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
64 changed files with 737 additions and 620 deletions
Download patch file Download diff file Expand all files Collapse all files

36
src/code/z_actor.c
View file

@ -1,4 +1,5 @@
#include "global.h"
#include "quake.h"
#include "vt.h"
#include "overlays/actors/ovl_Arms_Hook/z_arms_hook.h"
@ -2179,11 +2180,11 @@ void Actor_Draw(PlayState* play, Actor* actor) {
Lights_BindAll(lights, play->lightCtx.listHead, (actor->flags & ACTOR_FLAG_22) ? NULL : &actor->world.pos);
Lights_Draw(lights, play->state.gfxCtx);
if (actor->flags & ACTOR_FLAG_12) {
Matrix_SetTranslateRotateYXZ(actor->world.pos.x + play->mainCamera.skyboxOffset.x,
if (actor->flags & ACTOR_FLAG_IGNORE_QUAKE) {
Matrix_SetTranslateRotateYXZ(actor->world.pos.x + play->mainCamera.quakeOffset.x,
actor->world.pos.y +
((actor->shape.yOffset * actor->scale.y) + play->mainCamera.skyboxOffset.y),
actor->world.pos.z + play->mainCamera.skyboxOffset.z, &actor->shape.rot);
((actor->shape.yOffset * actor->scale.y) + play->mainCamera.quakeOffset.y),
actor->world.pos.z + play->mainCamera.quakeOffset.z, &actor->shape.rot);
} else {
Matrix_SetTranslateRotateYXZ(actor->world.pos.x, actor->world.pos.y + (actor->shape.yOffset * actor->scale.y),
actor->world.pos.z, &actor->shape.rot);
@ -3505,30 +3506,29 @@ void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, PlayState* play) {
CLOSE_DISPS(play->state.gfxCtx, "../z_actor.c", 8155);
}
void func_80033DB8(PlayState* play, s16 arg1, s16 arg2) {
s16 var = Quake_Add(&play->mainCamera, 3);
void Actor_RequestQuake(PlayState* play, s16 y, s16 duration) {
s16 quakeIndex = Quake_Request(&play->mainCamera, QUAKE_TYPE_3);
Quake_SetSpeed(var, 20000);
Quake_SetQuakeValues(var, arg1, 0, 0, 0);
Quake_SetCountdown(var, arg2);
Quake_SetSpeed(quakeIndex, 20000);
Quake_SetPerturbations(quakeIndex, y, 0, 0, 0);
Quake_SetDuration(quakeIndex, duration);
}
void func_80033E1C(PlayState* play, s16 arg1, s16 arg2, s16 arg3) {
s16 var = Quake_Add(&play->mainCamera, 3);
void Actor_RequestQuakeWithSpeed(PlayState* play, s16 y, s16 duration, s16 speed) {
s16 quakeIndex = Quake_Request(&play->mainCamera, QUAKE_TYPE_3);
Quake_SetSpeed(var, arg3);
Quake_SetQuakeValues(var, arg1, 0, 0, 0);
Quake_SetCountdown(var, arg2);
Quake_SetSpeed(quakeIndex, speed);
Quake_SetPerturbations(quakeIndex, y, 0, 0, 0);
Quake_SetDuration(quakeIndex, duration);
}
void func_80033E88(Actor* actor, PlayState* play, s16 arg2, s16 arg3) {
if (arg2 >= 5) {
void Actor_RequestQuakeAndRumble(Actor* actor, PlayState* play, s16 quakeY, s16 quakeDuration) {
if (quakeY >= 5) {
Rumble_Request(actor->xyzDistToPlayerSq, 255, 20, 150);
} else {
Rumble_Request(actor->xyzDistToPlayerSq, 180, 20, 100);
}
func_80033DB8(play, arg2, arg3);
Actor_RequestQuake(play, quakeY, quakeDuration);
}
f32 Rand_ZeroFloat(f32 f) {

89
src/code/z_camera.c
View file

@ -1,5 +1,6 @@
#include "ultra64.h"
#include "global.h"
#include "quake.h"
#include "vt.h"
#include "overlays/actors/ovl_En_Horse/z_en_horse.h"
@ -6972,7 +6973,7 @@ void Camera_Init(Camera* camera, View* view, CollisionContext* colCtx, PlayState
camera->up.y = 1.0f;
camera->up.z = camera->up.x = 0.0f;
camera->skyboxOffset.x = camera->skyboxOffset.y = camera->skyboxOffset.z = 0;
camera->quakeOffset.x = camera->quakeOffset.y = camera->quakeOffset.z = 0;
camera->atLERPStepScale = 1;
sCameraInterfaceFlags = 0xFF00;
sDbgModeIdx = -1;
@ -7185,11 +7186,11 @@ void Camera_PrintSettings(Camera* camera) {
s32 Camera_UpdateWater(Camera* camera) {
f32 waterY;
s16 newQuakeId;
s16 quakeIndex;
s32 waterLightsIndex;
s32* waterCamSetting = &camera->waterCamSetting;
s16 waterBgCamIndex;
s16* quakeId = (s16*)&camera->waterQuakeId;
s16* waterQuakeIndex = (s16*)&camera->waterQuakeIndex;
Player* player = camera->player;
s16 prevBgId;
@ -7213,7 +7214,7 @@ s32 Camera_UpdateWater(Camera* camera) {
camera->unk_14C |= 0x200;
camera->waterYPos = waterY;
camera->bgCamIndexBeforeUnderwater = camera->bgCamIndex;
*quakeId = -1;
*waterQuakeIndex = -1;
}
if (camera->playerGroundY != camera->playerPosRot.pos.y) {
prevBgId = camera->bgId;
@ -7229,7 +7230,7 @@ s32 Camera_UpdateWater(Camera* camera) {
camera->unk_14C |= 0x200;
camera->waterYPos = waterY;
camera->bgCamIndexBeforeUnderwater = camera->bgCamIndex;
*quakeId = -1;
*waterQuakeIndex = -1;
}
if (camera->playerGroundY != camera->playerPosRot.pos.y) {
prevBgId = camera->bgId;
@ -7266,16 +7267,19 @@ s32 Camera_UpdateWater(Camera* camera) {
Audio_SetExtraFilter(0x20);
if (PREG(81)) {
Quake_RemoveFromIdx(*quakeId);
*quakeId = -1;
Quake_RemoveRequest(*waterQuakeIndex);
*waterQuakeIndex = -1;
PREG(81) = 0;
}
if ((*quakeId == -1) || (Quake_GetCountdown(*quakeId) == 0xA)) {
if (*quakeId = newQuakeId = Quake_Add(camera, 5U), newQuakeId != 0) {
Quake_SetSpeed(*quakeId, 550);
Quake_SetQuakeValues(*quakeId, 1, 1, 180, 0);
Quake_SetCountdown(*quakeId, 1000);
if ((*waterQuakeIndex == -1) || (Quake_GetTimeLeft(*waterQuakeIndex) == 10)) {
quakeIndex = Quake_Request(camera, QUAKE_TYPE_5);
*waterQuakeIndex = quakeIndex;
if (quakeIndex != 0) {
Quake_SetSpeed(*waterQuakeIndex, 550);
Quake_SetPerturbations(*waterQuakeIndex, 1, 1, 180, 0);
Quake_SetDuration(*waterQuakeIndex, 1000);
}
}
@ -7292,8 +7296,8 @@ s32 Camera_UpdateWater(Camera* camera) {
camera->unk_14C &= ~0x100;
osSyncPrintf("kankyo changed water off, sound off\n");
Environment_DisableUnderwaterLights(camera->play);
if (*quakeId != 0) {
Quake_RemoveFromIdx(*quakeId);
if (*waterQuakeIndex != 0) {
Quake_RemoveRequest(*waterQuakeIndex);
}
camera->waterDistortionTimer = 0;
camera->distortionFlags = 0;
@ -7438,8 +7442,9 @@ Vec3s Camera_Update(Camera* camera) {
f32 playerXZSpeed;
VecSph eyeAtAngle;
s16 bgCamIndex;
s16 numQuakesApplied;
PosRot curPlayerPosRot;
QuakeCamCalc quake;
ShakeInfo camShake;
Player* player;
player = camera->play->cameraPtrs[CAM_ID_MAIN]->player;
@ -7602,19 +7607,23 @@ Vec3s Camera_Update(Camera* camera) {
return camera->inputDir;
}
// setting bgId to the ret of Quake_Calc, and checking that
// is required, it doesn't make too much sense though.
if ((bgId = Quake_Calc(camera, &quake), bgId != 0) && (camera->setting != CAM_SET_TURN_AROUND)) {
viewAt.x = camera->at.x + quake.atOffset.x;
viewAt.y = camera->at.y + quake.atOffset.y;
viewAt.z = camera->at.z + quake.atOffset.z;
viewEye.x = camera->eye.x + quake.eyeOffset.x;
viewEye.y = camera->eye.y + quake.eyeOffset.y;
viewEye.z = camera->eye.z + quake.eyeOffset.z;
numQuakesApplied = Quake_Update(camera, &camShake);
bgId = numQuakesApplied; // required to match
if ((numQuakesApplied != 0) && (camera->setting != CAM_SET_TURN_AROUND)) {
viewAt.x = camera->at.x + camShake.atOffset.x;
viewAt.y = camera->at.y + camShake.atOffset.y;
viewAt.z = camera->at.z + camShake.atOffset.z;
viewEye.x = camera->eye.x + camShake.eyeOffset.x;
viewEye.y = camera->eye.y + camShake.eyeOffset.y;
viewEye.z = camera->eye.z + camShake.eyeOffset.z;
OLib_Vec3fDiffToVecSphGeo(&eyeAtAngle, &viewEye, &viewAt);
Camera_CalcUpFromPitchYawRoll(&viewUp, eyeAtAngle.pitch + quake.rotZ, eyeAtAngle.yaw + quake.unk_1A,
camera->roll);
viewFov = camera->fov + CAM_BINANG_TO_DEG(quake.zoom);
Camera_CalcUpFromPitchYawRoll(&viewUp, eyeAtAngle.pitch + camShake.upPitchOffset,
eyeAtAngle.yaw + camShake.upYawOffset, camera->roll);
viewFov = camera->fov + CAM_BINANG_TO_DEG(camShake.fovOffset);
} else {
viewAt = camera->at;
viewEye = camera->eye;
@ -7630,7 +7639,7 @@ Vec3s Camera_Update(Camera* camera) {
camera->up = viewUp;
}
camera->skyboxOffset = quake.eyeOffset;
camera->quakeOffset = camShake.eyeOffset;
Camera_UpdateDistortion(camera);
@ -8010,17 +8019,17 @@ s16 Camera_GetCamDirYaw(Camera* camera) {
return camDir.y;
}
s32 Camera_AddQuake(Camera* camera, s32 arg1, s16 y, s32 countdown) {
s16 quakeIdx;
s32 Camera_RequestQuake(Camera* camera, s32 unused, s16 y, s32 duration) {
s16 quakeIndex;
quakeIdx = Quake_Add(camera, 3);
if (quakeIdx == 0) {
return 0;
quakeIndex = Quake_Request(camera, QUAKE_TYPE_3);
if (quakeIndex == 0) {
return false;
}
Quake_SetSpeed(quakeIdx, 0x61A8);
Quake_SetQuakeValues(quakeIdx, y, 0, 0, 0);
Quake_SetCountdown(quakeIdx, countdown);
return 1;
Quake_SetSpeed(quakeIndex, 0x61A8);
Quake_SetPerturbations(quakeIndex, y, 0, 0, 0);
Quake_SetDuration(quakeIndex, duration);
return true;
}
s32 Camera_SetParam(Camera* camera, s32 param, void* value) {
@ -8187,9 +8196,9 @@ s32 Camera_GetDbgCamEnabled(void) {
return gDbgCamEnabled;
}
Vec3f* Camera_GetSkyboxOffset(Vec3f* dst, Camera* camera) {
*dst = camera->skyboxOffset;
return dst;
Vec3f* Camera_GetQuakeOffset(Vec3f* quakeOffset, Camera* camera) {
*quakeOffset = camera->quakeOffset;
return quakeOffset;
}
void Camera_SetCameraData(Camera* camera, s16 setDataFlags, void* data0, void* data1, s16 data2, s16 data3,

9
src/code/z_demo.c
View file

@ -1,4 +1,5 @@
#include "global.h"
#include "quake.h"
#include "z64camera.h"
#include "assets/scenes/indoors/tokinoma/tokinoma_scene.h"
@ -311,15 +312,15 @@ void func_80064824(PlayState* play, CutsceneContext* csCtx, CsCmdBase* cmd) {
break;
case 16:
if (sp3F != 0) {
sQuakeIndex = Quake_Add(GET_ACTIVE_CAM(play), 6);
sQuakeIndex = Quake_Request(GET_ACTIVE_CAM(play), QUAKE_TYPE_6);
Quake_SetSpeed(sQuakeIndex, 0x7FFF);
Quake_SetQuakeValues(sQuakeIndex, 4, 0, 1000, 0);
Quake_SetCountdown(sQuakeIndex, 800);
Quake_SetPerturbations(sQuakeIndex, 4, 0, 1000, 0);
Quake_SetDuration(sQuakeIndex, 800);
}
break;
case 17:
if (sp3F != 0) {
Quake_RemoveFromIdx(sQuakeIndex);
Quake_RemoveRequest(sQuakeIndex);
}
break;
case 18:

115
src/code/z_onepointdemo.c
View file

@ -1,4 +1,5 @@
#include "global.h"
#include "quake.h"
#include "vt.h"
#include "overlays/actors/ovl_En_Sw/z_en_sw.h"
@ -156,10 +157,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
((mainCam->play->state.frames & 1) ? 3.0f : -3.0f) + Rand_ZeroOne();
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 5);
i = Quake_Request(subCam, QUAKE_TYPE_5);
Quake_SetSpeed(i, 400);
Quake_SetQuakeValues(i, 4, 5, 40, 0x3C);
Quake_SetCountdown(i, 1600);
Quake_SetPerturbations(i, 4, 5, 40, 0x3C);
Quake_SetDuration(i, 1600);
break;
case 2280:
csInfo->keyFrames = D_80120D4C;
@ -177,10 +178,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
((mainCam->play->state.frames & 1) ? 3.0f : -3.0f) + Rand_ZeroOne();
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 5);
i = Quake_Request(subCam, QUAKE_TYPE_5);
Quake_SetSpeed(i, 400);
Quake_SetQuakeValues(i, 2, 3, 200, 0x32);
Quake_SetCountdown(i, 9999);
Quake_SetPerturbations(i, 2, 3, 200, 0x32);
Quake_SetDuration(i, 9999);
break;
case 2220:
csInfo->keyFrames = D_80120E64;
@ -188,10 +189,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 5);
i = Quake_Request(subCam, QUAKE_TYPE_5);
Quake_SetSpeed(i, 400);
Quake_SetQuakeValues(i, 2, 2, 50, 0);
Quake_SetCountdown(i, 280);
Quake_SetPerturbations(i, 2, 2, 50, 0);
Quake_SetDuration(i, 280);
break;
case 2230:
if (player->actor.world.pos.z < 1000.0f) {
@ -210,10 +211,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 5);
i = Quake_Request(subCam, QUAKE_TYPE_5);
Quake_SetSpeed(i, 400);
Quake_SetQuakeValues(i, 2, 2, 50, 0);
Quake_SetCountdown(i, 60);
Quake_SetPerturbations(i, 2, 2, 50, 0);
Quake_SetDuration(i, 60);
break;
case 2350:
csInfo->keyFrames = D_8012110C;
@ -397,10 +398,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 3);
i = Quake_Request(subCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 22000);
Quake_SetQuakeValues(i, 2, 0, 200, 0);
Quake_SetCountdown(i, 10);
Quake_SetPerturbations(i, 2, 0, 200, 0);
Quake_SetDuration(i, 10);
break;
case 3080:
csInfo->keyFrames = D_80121774;
@ -435,10 +436,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_8002DF54(play, NULL, 8);
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 24000);
Quake_SetQuakeValues(i, 2, 0, 0, 0);
Quake_SetCountdown(i, 160);
Quake_SetPerturbations(i, 2, 0, 0, 0);
Quake_SetDuration(i, 160);
break;
case 3060:
csInfo->keyFrames = D_80121904;
@ -467,10 +468,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
D_8012021C[D_801202FC - 3].pos.z +=
(D_8012021C[D_801202FC - 2].pos.z - D_8012021C[D_801202FC - 3].pos.z) / 2;
i = Quake_Add(mainCam, 3);
i = Quake_Request(mainCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 30000);
Quake_SetQuakeValues(i, 2, 1, 1, 0);
Quake_SetCountdown(i, 200);
Quake_SetPerturbations(i, 2, 1, 1, 0);
Quake_SetDuration(i, 200);
break;
case 3120:
csInfo->keyFrames = D_80121954[-(timer + 101)];
@ -583,10 +584,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
Play_CameraSetAtEye(play, CAM_ID_MAIN, &spC0, &spB4);
i = Quake_Add(subCam, 3);
i = Quake_Request(subCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 22000);
Quake_SetQuakeValues(i, 1, 0, 0, 0);
Quake_SetCountdown(i, 90);
Quake_SetPerturbations(i, 1, 0, 0, 0);
Quake_SetDuration(i, 90);
break;
case 6010:
Actor_GetWorld(&spA0, actor);
@ -637,10 +638,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
OnePointCutscene_SetCsCamPoints(subCam, D_801208E8, D_801208E4, D_801206A0, D_80120760);
}
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 32000);
Quake_SetQuakeValues(i, 0, 0, 20, 0);
Quake_SetCountdown(i, D_801208E4 - 10);
Quake_SetPerturbations(i, 0, 0, 20, 0);
Quake_SetDuration(i, D_801208E4 - 10);
break;
case 3400:
Play_CameraChangeSetting(play, subCamId, CAM_SET_CS_3);
@ -649,10 +650,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
OnePointCutscene_Vec3sToVec3f(&mainCam->eye, &D_801205B4[D_80120694 - 2].pos);
OnePointCutscene_Vec3sToVec3f(&mainCam->at, &D_801204D4[D_80120694 - 2].pos);
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 0x4E20);
Quake_SetQuakeValues(i, 1, 0, 50, 0);
Quake_SetCountdown(i, D_80120698 - 20);
Quake_SetPerturbations(i, 1, 0, 50, 0);
Quake_SetDuration(i, D_80120698 - 20);
break;
case 3390:
player->actor.shape.rot.y = player->actor.world.rot.y = player->currentYaw = -0x3FD9;
@ -668,10 +669,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_8002DF54(play, NULL, 8);
Play_CopyCamera(play, subCamId, CAM_ID_MAIN);
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 32000);
Quake_SetQuakeValues(i, 2, 0, 0, 0);
Quake_SetCountdown(i, timer);
Quake_SetPerturbations(i, 2, 0, 0, 0);
Quake_SetDuration(i, timer);
break;
case 3290:
D_80121F1C[0].atTargetInit = play->view.at;
@ -685,10 +686,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 3);
i = Quake_Request(subCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 12000);
Quake_SetQuakeValues(i, 0, 0, 1000, 0);
Quake_SetCountdown(i, 5);
Quake_SetPerturbations(i, 0, 0, 1000, 0);
Quake_SetDuration(i, 5);
break;
case 3340:
D_80121FBC[0].atTargetInit = play->view.at;
@ -701,10 +702,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_8002DF54(play, NULL, 8);
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 3);
i = Quake_Request(subCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 12000);
Quake_SetQuakeValues(i, 0, 0, 1000, 0);
Quake_SetCountdown(i, 5);
Quake_SetPerturbations(i, 0, 0, 1000, 0);
Quake_SetDuration(i, 5);
break;
case 3360:
csInfo->keyFrames = D_8012205C;
@ -746,10 +747,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_8002DF54(play, NULL, 8);
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 32000);
Quake_SetQuakeValues(i, 4, 0, 0, 0);
Quake_SetCountdown(i, 20);
Quake_SetPerturbations(i, 4, 0, 0, 0);
Quake_SetDuration(i, 20);
break;
case 3450:
csInfo->keyFrames = D_8012237C;
@ -758,10 +759,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_8002DF38(play, &player->actor, 8);
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 32000);
Quake_SetQuakeValues(i, 2, 0, 0, 0);
Quake_SetCountdown(i, 10);
Quake_SetPerturbations(i, 2, 0, 0, 0);
Quake_SetDuration(i, 10);
break;
case 3440:
csInfo->keyFrames = D_801223CC;
@ -772,10 +773,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
player->stateFlags1 |= PLAYER_STATE1_29;
player->actor.freezeTimer = 90;
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 32000);
Quake_SetQuakeValues(i, 2, 0, 0, 0);
Quake_SetCountdown(i, 10);
Quake_SetPerturbations(i, 2, 0, 0, 0);
Quake_SetDuration(i, 10);
break;
case 3430:
csInfo->keyFrames = D_801224BC;
@ -784,10 +785,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_8002DF54(play, NULL, 8);
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 1);
i = Quake_Request(subCam, QUAKE_TYPE_1);
Quake_SetSpeed(i, 32000);
Quake_SetQuakeValues(i, 1, 0, 10, 0);
Quake_SetCountdown(i, 20);
Quake_SetPerturbations(i, 1, 0, 10, 0);
Quake_SetDuration(i, 20);
break;
case 4100:
csInfo->keyFrames = D_801225D4;
@ -867,10 +868,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
i = Quake_Add(subCam, 3);
i = Quake_Request(subCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 12000);
Quake_SetQuakeValues(i, 0, 1, 100, 0);
Quake_SetCountdown(i, timer - 80);
Quake_SetPerturbations(i, 0, 1, 100, 0);
Quake_SetDuration(i, timer - 80);
break;
case 4220:
csInfo->keyFrames = (player->actor.world.pos.z < -15.0f) ? D_80122C3C : D_80122C64;
@ -879,10 +880,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
func_800C0808(play, subCamId, player, CAM_SET_CS_C);
func_8002DF38(play, &player->actor, 1);
i = Quake_Add(subCam, 3);
i = Quake_Request(subCam, QUAKE_TYPE_3);
Quake_SetSpeed(i, 12000);
Quake_SetQuakeValues(i, 0, 1, 10, 0);
Quake_SetCountdown(i, timer - 10);
Quake_SetPerturbations(i, 0, 1, 10, 0);
Quake_SetDuration(i, timer - 10);
break;
case 4221:
csInfo->keyFrames = D_80122C8C;

9
src/code/z_play.c
View file

@ -1,4 +1,5 @@
#include "global.h"
#include "quake.h"
#include "vt.h"
void* D_8012D1F0 = NULL;
@ -1176,11 +1177,11 @@ void Play_Draw(PlayState* this) {
if ((HREG(80) != 10) || (HREG(83) != 0)) {
if ((this->skyboxCtx.unk_140 != 0) && (GET_ACTIVE_CAM(this)->setting != CAM_SET_PREREND_FIXED)) {
Vec3f sp74;
Vec3f quakeOffset;
Camera_GetSkyboxOffset(&sp74, GET_ACTIVE_CAM(this));
SkyboxDraw_Draw(&this->skyboxCtx, gfxCtx, this->skyboxId, 0, this->view.eye.x + sp74.x,
this->view.eye.y + sp74.y, this->view.eye.z + sp74.z);
Camera_GetQuakeOffset(&quakeOffset, GET_ACTIVE_CAM(this));
SkyboxDraw_Draw(&this->skyboxCtx, gfxCtx, this->skyboxId, 0, this->view.eye.x + quakeOffset.x,
this->view.eye.y + quakeOffset.y, this->view.eye.z + quakeOffset.z);
}
}

615
src/code/z_quake.c
View file

@ -1,280 +1,362 @@
#include "global.h"
#include "quake.h"
#include "vt.h"
QuakeRequest sQuakeRequest[4];
s16 D_80126250 = 1;
typedef struct {
/* 0x00 */ s16 index;
/* 0x02 */ s16 duration;
/* 0x04 */ Camera* cam;
/* 0x08 */ u32 type;
/* 0x0C */ s16 y;
/* 0x0E */ s16 x;
/* 0x10 */ s16 fov;
/* 0x12 */ s16 upPitchOffset;
/* 0x14 */ Vec3s orientation; // alters the orientation of the xy perturbation. Only x (pitch) and y (yaw) are used
/* 0x1A */ s16 speed;
/* 0x1C */ s16 isRelativeToScreen; // is the quake relative to the screen or on world coordinates
/* 0x1E */ s16 timer;
/* 0x20 */ s16 camId;
} QuakeRequest; // size = 0x24
QuakeRequest sQuakeRequests[4];
s16 sQuakeUnused = 1;
s16 sQuakeRequestCount = 0;
s16 (*sQuakeCallbacks[])(QuakeRequest*, ShakeInfo*) = {
NULL, Quake_Callback1, Quake_Callback2, Quake_Callback3, Quake_Callback4, Quake_Callback5, Quake_Callback6,
};
Vec3f* Quake_VecSphGeoAddToVec3f(Vec3f* dst, Vec3f* a, VecSph* sph) {
Vec3f vec;
Vec3f b;
Vec3f* Quake_AddVec(Vec3f* dst, Vec3f* arg1, VecSph* arg2) {
Vec3f vec1;
Vec3f vec2;
OLib_VecSphGeoToVec3f(&b, sph);
vec.x = a->x + b.x;
vec.y = a->y + b.y;
vec.z = a->z + b.z;
*dst = vec;
OLib_VecSphGeoToVec3f(&vec2, arg2);
vec1.x = arg1->x + vec2.x;
vec1.y = arg1->y + vec2.y;
vec1.z = arg1->z + vec2.z;
*dst = vec1;
return dst;
}
void Quake_UpdateShakeInfo(QuakeRequest* req, ShakeInfo* shake, f32 y, f32 x) {
Vec3f* unk50 = &req->cam->at;
Vec3f* unk5C = &req->cam->eye;
Vec3f* at = &req->cam->at;
Vec3f* eye = &req->cam->eye;
Vec3f offset;
VecSph sph;
VecSph eyeToAtSph;
Vec3f vec;
VecSph struc2;
VecSph struc1;
Vec3f vec2;
if (req->isRelativeToScreen) {
offset.x = 0;
offset.y = 0;
offset.z = 0;
OLib_Vec3fDiffToVecSphGeo(&eyeToAtSph, eye, at);
if (req->unk_1C) {
vec.x = 0;
vec.y = 0;
vec.z = 0;
OLib_Vec3fDiffToVecSphGeo(&struc1, unk5C, unk50);
struc2.r = req->y * y;
struc2.pitch = struc1.pitch + req->unk_14.unk_00 + 0x4000;
struc2.yaw = struc1.yaw + req->unk_14.unk_02;
Quake_AddVec(&vec, &vec, &struc2);
struc2.r = req->x * x;
struc2.pitch = struc1.pitch + req->unk_14.unk_00;
struc2.yaw = struc1.yaw + req->unk_14.unk_02 + 0x4000;
Quake_AddVec(&vec, &vec, &struc2);
// y shake
sph.r = req->y * y;
// point unit vector up, then add on `req->orientation`
sph.pitch = eyeToAtSph.pitch + req->orientation.x + 0x4000;
sph.yaw = eyeToAtSph.yaw + req->orientation.y;
// apply y shake
Quake_VecSphGeoAddToVec3f(&offset, &offset, &sph);
// x shake
sph.r = req->x * x;
// point unit vector left, then add on `req->orientation`
sph.pitch = eyeToAtSph.pitch + req->orientation.x;
sph.yaw = eyeToAtSph.yaw + req->orientation.y + 0x4000;
// apply x shake
Quake_VecSphGeoAddToVec3f(&offset, &offset, &sph);
} else {
vec.x = 0;
vec.y = req->y * y;
vec.z = 0;
struc2.r = req->x * x;
struc2.pitch = req->unk_14.unk_00;
struc2.yaw = req->unk_14.unk_02;
Quake_AddVec(&vec, &vec, &struc2);
offset.x = 0;
offset.y = req->y * y;
offset.z = 0;
sph.r = req->x * x;
sph.pitch = req->orientation.x;
sph.yaw = req->orientation.y;
Quake_VecSphGeoAddToVec3f(&offset, &offset, &sph);
}
vec2 = vec;
shake->vec2 = vec2;
shake->vec1 = vec2;
shake->unk_1A = (f32)0x8000 * y;
shake->rotZ = req->rotZ * y;
shake->zoom = req->zoom * y;
shake->atOffset = shake->eyeOffset = offset;
shake->upYawOffset = 0x8000 * y;
shake->upPitchOffset = req->upPitchOffset * y;
shake->fovOffset = req->fov * y;
}
s16 Quake_Callback1(QuakeRequest* req, ShakeInfo* shake) {
s16 Quake_CallbackType1(QuakeRequest* req, ShakeInfo* shake) {
s32 pad;
if (req->countdown > 0) {
f32 a = Math_SinS(req->speed * req->countdown);
if (req->timer > 0) {
f32 xyOffset = Math_SinS(req->speed * req->timer);
Quake_UpdateShakeInfo(req, shake, a, Rand_ZeroOne() * a);
req->countdown--;
Quake_UpdateShakeInfo(req, shake, xyOffset, Rand_ZeroOne() * xyOffset);
req->timer--;
}
return req->countdown;
return req->timer;
}
s16 Quake_Callback5(QuakeRequest* req, ShakeInfo* shake) {
if (req->countdown > 0) {
f32 a = Math_SinS(req->speed * req->countdown);
s16 Quake_CallbackType5(QuakeRequest* req, ShakeInfo* shake) {
if (req->timer > 0) {
f32 xyOffset = Math_SinS(req->speed * req->timer);
Quake_UpdateShakeInfo(req, shake, a, a);
req->countdown--;
Quake_UpdateShakeInfo(req, shake, xyOffset, xyOffset);
req->timer--;
}
return req->countdown;
return req->timer;
}
s16 Quake_Callback6(QuakeRequest* req, ShakeInfo* shake) {
s16 Quake_CallbackType6(QuakeRequest* req, ShakeInfo* shake) {
s32 pad;
f32 a;
f32 xyOffset;
req->countdown--;
a = Math_SinS(req->speed * ((req->countdown & 0xF) + 500));
Quake_UpdateShakeInfo(req, shake, a, Rand_ZeroOne() * a);
req->timer--;
xyOffset = Math_SinS(req->speed * ((req->timer & 0xF) + 500));
Quake_UpdateShakeInfo(req, shake, xyOffset, Rand_ZeroOne() * xyOffset);
// Not returning the timer ensures quake type 6 continues indefinitely until manually removed
return 1;
}
s16 Quake_Callback3(QuakeRequest* req, ShakeInfo* shake) {
if (req->countdown > 0) {
f32 a = Math_SinS(req->speed * req->countdown) * ((f32)req->countdown / (f32)req->countdownMax);
s16 Quake_CallbackType3(QuakeRequest* req, ShakeInfo* shake) {
if (req->timer > 0) {
f32 xyOffset = Math_SinS(req->speed * req->timer) * ((f32)req->timer / req->duration);
Quake_UpdateShakeInfo(req, shake, a, a);
req->countdown--;
Quake_UpdateShakeInfo(req, shake, xyOffset, xyOffset);
req->timer--;
}
return req->countdown;
return req->timer;
}
s16 Quake_Callback2(QuakeRequest* req, ShakeInfo* shake) {
if (req->countdown > 0) {
f32 a = Rand_ZeroOne();
s16 Quake_CallbackType2(QuakeRequest* req, ShakeInfo* shake) {
if (req->timer > 0) {
f32 xyOffset = Rand_ZeroOne();
Quake_UpdateShakeInfo(req, shake, a, Rand_ZeroOne() * a);
req->countdown--;
Quake_UpdateShakeInfo(req, shake, xyOffset, Rand_ZeroOne() * xyOffset);
req->timer--;
}
return req->countdown;
return req->timer;
}
s16 Quake_Callback4(QuakeRequest* req, ShakeInfo* shake) {
if (req->countdown > 0) {
f32 a = Rand_ZeroOne() * ((f32)req->countdown / (f32)req->countdownMax);
s16 Quake_CallbackType4(QuakeRequest* req, ShakeInfo* shake) {
if (req->timer > 0) {
f32 xyOffset = Rand_ZeroOne() * ((f32)req->timer / req->duration);
Quake_UpdateShakeInfo(req, shake, a, Rand_ZeroOne() * a);
req->countdown--;
Quake_UpdateShakeInfo(req, shake, xyOffset, Rand_ZeroOne() * xyOffset);
req->timer--;
}
return req->countdown;
return req->timer;
}
s16 Quake_GetFreeIndex(void) {
s32 i;
s32 ret;
s32 min = 0x10000;
s32 index;
s32 timerMin = 0x10000; // UINT16_MAX + 1
for (i = 0; i < ARRAY_COUNT(sQuakeRequest); i++) {
if (sQuakeRequest[i].callbackIdx == 0) {
ret = i;
min = 0x20000;
for (i = 0; i < ARRAY_COUNT(sQuakeRequests); i++) {
if (sQuakeRequests[i].type == QUAKE_TYPE_NONE) {
index = i;
timerMin = 0x20000; // Magic Number to indicate there was an unused quake index
break;
}
if (sQuakeRequest[i].countdown < min) {
min = sQuakeRequest[i].countdown;
ret = i;
if (timerMin > sQuakeRequests[i].timer) {
timerMin = sQuakeRequests[i].timer;
index = i;
}
}
if (min != 0x20000) {
osSyncPrintf(VT_COL(YELLOW, BLACK) "quake: too many request %d is changed new one !!\n" VT_RST, ret);
if (timerMin != 0x20000) {
osSyncPrintf(VT_COL(YELLOW, BLACK) "quake: too many request %d is changed new one !!\n" VT_RST, index);
}
return ret;
return index;
}
QuakeRequest* Quake_AddImpl(Camera* camera, u32 callbackIdx) {
s16 idx = Quake_GetFreeIndex();
QuakeRequest* req = &sQuakeRequest[idx];
QuakeRequest* Quake_RequestImpl(Camera* camera, u32 type) {
s16 index = Quake_GetFreeIndex();
QuakeRequest* req = &sQuakeRequests[index];
__osMemset(req, 0, sizeof(QuakeRequest));
req->cam = camera;
req->camPtrIdx = camera->camId;
req->callbackIdx = callbackIdx;
req->unk_1C = 1;
req->randIdx = ((s16)(Rand_ZeroOne() * (f32)0x10000) & ~3) + idx;
req->camId = camera->camId;
req->type = type;
req->isRelativeToScreen = true;
// Add a unique random identifier to the upper bits of the index
// The `~3` assumes there are only 4 requests
req->index = index + ((s16)(Rand_ZeroOne() * 0x10000) & ~3);
sQuakeRequestCount++;
return req;
}
void Quake_Remove(QuakeRequest* req) {
req->callbackIdx = 0;
req->countdown = -1;
req->type = QUAKE_TYPE_NONE;
req->timer = -1;
sQuakeRequestCount--;
}
QuakeRequest* Quake_GetRequest(s16 idx) {
QuakeRequest* req = &sQuakeRequest[idx & 3];
QuakeRequest* Quake_GetRequest(s16 index) {
QuakeRequest* req = &sQuakeRequests[index & 3];
if (req->callbackIdx == 0) {
if (req->type == QUAKE_TYPE_NONE) {
return NULL;
}
if (idx != req->randIdx) {
if (index != req->index) {
return NULL;
}
return req;
}
QuakeRequest* Quake_SetValue(s16 idx, s16 valueType, s16 value) {
QuakeRequest* req = Quake_GetRequest(idx);
#define QUAKE_SPEED (1 << 0)
#define QUAKE_Y_OFFSET (1 << 1)
#define QUAKE_X_OFFSET (1 << 2)
#define QUAKE_FOV (1 << 3)
#define QUAKE_ROLL (1 << 4)
#define QUAKE_ORIENTATION_PITCH (1 << 5)
#define QUAKE_ORIENTATION_YAW (1 << 6)
#define QUAKE_ORIENTATION_ROLL (1 << 7)
#define QUAKE_DURATION (1 << 8)
#define QUAKE_IS_RELATIVE_TO_SCREEN (1 << 9)
QuakeRequest* Quake_SetValue(s16 index, s16 valueType, s16 value) {
QuakeRequest* req = Quake_GetRequest(index);
if (req == NULL) {
return NULL;
} else {
switch (valueType) {
case 1:
req->speed = value;
break;
case 2:
req->y = value;
break;
case 4:
req->x = value;
break;
case 8:
req->zoom = value;
break;
case 0x10:
req->rotZ = value;
break;
case 0x20:
req->unk_14.unk_00 = value;
break;
case 0x40:
req->unk_14.unk_02 = value;
break;
case 0x80:
req->unk_14.unk_04 = value;
break;
case 0x100:
req->countdown = value;
req->countdownMax = req->countdown;
break;
case 0x200:
req->unk_1C = value;
break;
}
}
switch (valueType) {
case QUAKE_SPEED:
req->speed = value;
break;
case QUAKE_Y_OFFSET:
req->y = value;
break;
case QUAKE_X_OFFSET:
req->x = value;
break;
case QUAKE_FOV:
req->fov = value;
break;
case QUAKE_ROLL:
req->upPitchOffset = value;
break;
case QUAKE_ORIENTATION_PITCH:
req->orientation.x = value;
break;
case QUAKE_ORIENTATION_YAW:
req->orientation.y = value;
break;
case QUAKE_ORIENTATION_ROLL:
req->orientation.z = value;
break;
case QUAKE_DURATION:
req->timer = value;
req->duration = req->timer;
break;
case QUAKE_IS_RELATIVE_TO_SCREEN:
req->isRelativeToScreen = value;
break;
default:
break;
}
//! @bug UB: missing return. "req" is in v0 at this point, but doing an
//! explicit return uses an additional register.
#ifdef AVOID_UB
return req;
#endif
}
u32 Quake_SetSpeed(s16 idx, s16 value) {
QuakeRequest* req = Quake_GetRequest(idx);
/**
* @param index
* @param speed For periodic types only, the angular frequency of the sine wave (binang / frame)
* @return true if successfully applied, false if the request does not exist
*/
u32 Quake_SetSpeed(s16 index, s16 speed) {
QuakeRequest* req = Quake_GetRequest(index);
if (req != NULL) {
req->speed = value;
req->speed = speed;
return true;
}
return false;
}
u32 Quake_SetCountdown(s16 idx, s16 value) {
QuakeRequest* req = Quake_GetRequest(idx);
/**
* @param index quake request index to apply
* @param duration Number of frames to apply the quake
* @return true if successfully applied, false if the request does not exist
*/
u32 Quake_SetDuration(s16 index, s16 duration) {
QuakeRequest* req = Quake_GetRequest(index);
if (req != NULL) {
req->countdown = value;
req->countdownMax = req->countdown;
req->duration = req->timer = duration;
return true;
}
return false;
}
s16 Quake_GetCountdown(s16 idx) {
QuakeRequest* req = Quake_GetRequest(idx);
/**
* @param index quake request index to get
* @return Number of frames until the quake is finished
*/
s16 Quake_GetTimeLeft(s16 index) {
QuakeRequest* req = Quake_GetRequest(index);
if (req != NULL) {
return req->countdown;
return req->timer;
}
return 0;
}
u32 Quake_SetQuakeValues(s16 idx, s16 y, s16 x, s16 zoom, s16 rotZ) {
QuakeRequest* req = Quake_GetRequest(idx);
/**
* @param index quake request index to apply
* @param y Apply up/down shake
* @param x Apply left/right shake
* @param fov Apply zooming in/out shake (binang)
* @param roll Apply rolling shake (binang)
* @return true if successfully applied, false if the request does not exist
*/
u32 Quake_SetPerturbations(s16 index, s16 y, s16 x, s16 fov, s16 roll) {
QuakeRequest* req = Quake_GetRequest(index);
if (req != NULL) {
req->y = y;
req->x = x;
req->zoom = zoom;
req->rotZ = rotZ;
req->fov = fov;
// Visual roll is indirectly achieved by offsetting the pitch in calculating the camera "Up" vector
req->upPitchOffset = roll;
return true;
}
return false;
}
u32 Quake_SetUnkValues(s16 idx, s16 arg1, SubQuakeRequest14 arg2) {
QuakeRequest* req = Quake_GetRequest(idx);
/**
* @param index quake request index to apply
* @param isRelativeToScreen Is the quake applied relative to the screen or in absolute world coordinates
* @param orientation orient the x/y shake to a different direction
* @return true if successfully applied, false if the request does not exist
*/
u32 Quake_SetOrientation(s16 index, s16 isRelativeToScreen, Vec3s orientation) {
QuakeRequest* req = Quake_GetRequest(index);
if (req != NULL) {
req->unk_1C = arg1;
req->unk_14 = arg2;
req->isRelativeToScreen = isRelativeToScreen;
req->orientation = orientation;
return true;
}
return false;
@ -283,20 +365,20 @@ u32 Quake_SetUnkValues(s16 idx, s16 arg1, SubQuakeRequest14 arg2) {
void Quake_Init(void) {
s16 i;
for (i = 0; i < ARRAY_COUNT(sQuakeRequest); i++) {
sQuakeRequest[i].callbackIdx = 0;
sQuakeRequest[i].countdown = 0;
for (i = 0; i < ARRAY_COUNT(sQuakeRequests); i++) {
sQuakeRequests[i].type = QUAKE_TYPE_NONE;
sQuakeRequests[i].timer = 0;
}
D_80126250 = 1;
sQuakeUnused = 1;
sQuakeRequestCount = 0;
}
s16 Quake_Add(Camera* camera, u32 callbackIdx) {
return Quake_AddImpl(camera, callbackIdx)->randIdx;
s16 Quake_Request(Camera* camera, u32 type) {
return Quake_RequestImpl(camera, type)->index;
}
u32 Quake_RemoveFromIdx(s16 idx) {
QuakeRequest* req = Quake_GetRequest(idx);
u32 Quake_RemoveRequest(s16 index) {
QuakeRequest* req = Quake_GetRequest(index);
if (req != NULL) {
Quake_Remove(req);
@ -305,101 +387,120 @@ u32 Quake_RemoveFromIdx(s16 idx) {
return false;
}
s16 Quake_Calc(Camera* camera, QuakeCamCalc* camData) {
f32 max;
f32 max2;
QuakeRequest* req;
ShakeInfo shake;
f32 absSpeedDiv;
s16* temp;
u32 pad2;
s32 idx;
s32 ret;
u32 eq;
Vec3f vec;
PlayState* play;
s16 (*sQuakeCallbacks[])(QuakeRequest*, ShakeInfo*) = {
NULL, // QUAKE_TYPE_NONE
Quake_CallbackType1, // QUAKE_TYPE_1
Quake_CallbackType2, // QUAKE_TYPE_2
Quake_CallbackType3, // QUAKE_TYPE_3
Quake_CallbackType4, // QUAKE_TYPE_4
Quake_CallbackType5, // QUAKE_TYPE_5
Quake_CallbackType6, // QUAKE_TYPE_6
};
play = camera->play;
vec.x = 0.0f;
vec.y = 0.0f;
vec.z = 0.0f;
camData->rotZ = 0;
camData->unk_1A = 0;
camData->zoom = 0;
camData->atOffset.x = 0.0f;
camData->atOffset.y = 0.0f;
camData->atOffset.z = 0.0f;
camData->eyeOffset.x = 0.0f;
camData->eyeOffset.y = 0.0f;
camData->eyeOffset.z = 0.0f;
camData->unk_20 = 0.0f;
s16 Quake_Update(Camera* camera, ShakeInfo* camShake) {
f32 maxCurr;
f32 maxNext;
ShakeInfo shake;
QuakeRequest* req;
f32 absSpeedDiv;
s16* camId;
s32 index;
s32 numQuakesApplied;
u32 isDifferentCamId;
Vec3f zeroVec;
PlayState* play = camera->play;
zeroVec.x = 0.0f;
zeroVec.y = 0.0f;
zeroVec.z = 0.0f;
camShake->upPitchOffset = 0;
camShake->upYawOffset = 0;
camShake->fovOffset = 0;
camShake->atOffset.x = 0.0f;
camShake->atOffset.y = 0.0f;
camShake->atOffset.z = 0.0f;
camShake->eyeOffset.x = 0.0f;
camShake->eyeOffset.y = 0.0f;
camShake->eyeOffset.z = 0.0f;
camShake->maxOffset = 0.0f;
if (sQuakeRequestCount == 0) {
return 0;
}
ret = 0;
for (idx = 0; idx < ARRAY_COUNT(sQuakeRequest); idx++) {
req = &sQuakeRequest[idx];
if (req->callbackIdx != 0) {
if (play->cameraPtrs[req->camPtrIdx] == NULL) {
osSyncPrintf(VT_COL(YELLOW, BLACK) "quake: stopped! 'coz camera [%d] killed!!\n" VT_RST,
req->camPtrIdx);
Quake_Remove(req);
} else {
temp = &camera->camId;
eq = req->cam->camId != *temp;
absSpeedDiv = ABS(req->speed) / (f32)0x8000;
if (sQuakeCallbacks[req->callbackIdx](req, &shake) == 0) {
Quake_Remove(req);
} else if (eq == 0) {
if (fabsf(camData->atOffset.x) < fabsf(shake.vec1.x)) {
camData->atOffset.x = shake.vec1.x;
}
if (fabsf(camData->atOffset.y) < fabsf(shake.vec1.y)) {
camData->atOffset.y = shake.vec1.y;
}
if (fabsf(camData->atOffset.z) < fabsf(shake.vec1.z)) {
camData->atOffset.z = shake.vec1.z;
}
if (fabsf(camData->eyeOffset.x) < fabsf(shake.vec2.x)) {
camData->eyeOffset.x = shake.vec2.x;
}
if (fabsf(camData->eyeOffset.y) < fabsf(shake.vec2.y)) {
camData->eyeOffset.y = shake.vec2.y;
}
if (fabsf(camData->eyeOffset.z) < fabsf(shake.vec2.z)) {
camData->eyeOffset.z = shake.vec2.z;
}
if (camData->rotZ < shake.rotZ) {
camData->rotZ = shake.rotZ;
camData->unk_1A = shake.unk_1A;
}
if (camData->zoom < shake.zoom) {
camData->zoom = shake.zoom;
}
max = OLib_Vec3fDist(&shake.vec1, &vec) * absSpeedDiv;
max2 = OLib_Vec3fDist(&shake.vec2, &vec) * absSpeedDiv;
if (max < max2) {
max = max2;
}
max2 = (camData->rotZ * 0.005f) * absSpeedDiv;
if (max < max2) {
max = max2;
}
max2 = (camData->zoom * 0.005f) * absSpeedDiv;
if (max < max2) {
max = max2;
}
if (camData->unk_20 < max) {
camData->unk_20 = max;
}
ret++;
}
}
numQuakesApplied = 0;
for (index = 0; index < ARRAY_COUNT(sQuakeRequests); index++) {
req = &sQuakeRequests[index];
if (req->type == QUAKE_TYPE_NONE) {
continue;
}
if (play->cameraPtrs[req->camId] == NULL) {
osSyncPrintf(VT_COL(YELLOW, BLACK) "quake: stopped! 'coz camera [%d] killed!!\n" VT_RST, req->camId);
Quake_Remove(req);
continue;
}
camId = &camera->camId;
isDifferentCamId = req->cam->camId != *camId;
absSpeedDiv = (f32)ABS(req->speed) / 0x8000;
if (sQuakeCallbacks[req->type](req, &shake) == 0) {
// Quake has reached the end of its timer.
Quake_Remove(req);
continue;
}
if (isDifferentCamId) {
// Quake is attached to a different camId
continue;
}
if (fabsf(camShake->atOffset.x) < fabsf(shake.atOffset.x)) {
camShake->atOffset.x = shake.atOffset.x;
}
if (fabsf(camShake->atOffset.y) < fabsf(shake.atOffset.y)) {
camShake->atOffset.y = shake.atOffset.y;
}
if (fabsf(camShake->atOffset.z) < fabsf(shake.atOffset.z)) {
camShake->atOffset.z = shake.atOffset.z;
}
if (fabsf(camShake->eyeOffset.x) < fabsf(shake.eyeOffset.x)) {
camShake->eyeOffset.x = shake.eyeOffset.x;
}
if (fabsf(camShake->eyeOffset.y) < fabsf(shake.eyeOffset.y)) {
camShake->eyeOffset.y = shake.eyeOffset.y;
}
if (fabsf(camShake->eyeOffset.z) < fabsf(shake.eyeOffset.z)) {
camShake->eyeOffset.z = shake.eyeOffset.z;
}
if (camShake->upPitchOffset < shake.upPitchOffset) {
camShake->upPitchOffset = shake.upPitchOffset;
camShake->upYawOffset = shake.upYawOffset;
}
if (camShake->fovOffset < shake.fovOffset) {
camShake->fovOffset = shake.fovOffset;
}
maxCurr = OLib_Vec3fDist(&shake.atOffset, &zeroVec) * absSpeedDiv;
maxNext = OLib_Vec3fDist(&shake.eyeOffset, &zeroVec) * absSpeedDiv;
maxCurr = CLAMP_MIN(maxCurr, maxNext);
maxNext = camShake->upPitchOffset * (1.0f / 200.0f) * absSpeedDiv;
maxCurr = CLAMP_MIN(maxCurr, maxNext);
maxNext = camShake->fovOffset * (1.0f / 200.0f) * absSpeedDiv;
maxCurr = CLAMP_MIN(maxCurr, maxNext);
if (camShake->maxOffset < maxCurr) {
camShake->maxOffset = maxCurr;
}
numQuakesApplied++;
}
return ret;
return numQuakesApplied;
}

4
src/code/z_room.c
View file

@ -389,7 +389,7 @@ void Room_DrawImageSingle(PlayState* play, Room* room, u32 flags) {
Vec3f quakeOffset;
gfx = POLY_OPA_DISP;
Camera_GetSkyboxOffset(&quakeOffset, activeCam);
Camera_GetQuakeOffset(&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,
@ -487,7 +487,7 @@ void Room_DrawImageMulti(PlayState* play, Room* room, u32 flags) {
Vec3f quakeOffset;
gfx = POLY_OPA_DISP;
Camera_GetSkyboxOffset(&quakeOffset, activeCam);
Camera_GetQuakeOffset(&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,

19
src/code/z_scene_table.c
View file

@ -1,4 +1,5 @@
#include "global.h"
#include "quake.h"
#include "assets/scenes/overworld/spot00/spot00_scene.h"
#include "assets/scenes/overworld/spot00/spot00_room_0.h"
@ -585,20 +586,20 @@ void Scene_DrawConfigGanonCastleExterior(PlayState* play) {
// Screen Shake for Ganon's Tower Collapse
void func_8009BEEC(PlayState* play) {
s32 var;
s32 quakeIndex;
if (play->gameplayFrames % 128 == 13) {
var = Quake_Add(GET_ACTIVE_CAM(play), 2);
Quake_SetSpeed(var, 10000);
Quake_SetQuakeValues(var, 4, 0, 0, 0);
Quake_SetCountdown(var, 127);
quakeIndex = Quake_Request(GET_ACTIVE_CAM(play), QUAKE_TYPE_2);
Quake_SetSpeed(quakeIndex, 10000);
Quake_SetPerturbations(quakeIndex, 4, 0, 0, 0);
Quake_SetDuration(quakeIndex, 127);
}
if ((play->gameplayFrames % 64 == 0) && (Rand_ZeroOne() > 0.6f)) {
var = Quake_Add(GET_ACTIVE_CAM(play), 3);
Quake_SetSpeed(var, 32000.0f + (Rand_ZeroOne() * 3000.0f));
Quake_SetQuakeValues(var, 10.0f - (Rand_ZeroOne() * 9.0f), 0, 0, 0);
Quake_SetCountdown(var, 48.0f - (Rand_ZeroOne() * 15.0f));
quakeIndex = Quake_Request(GET_ACTIVE_CAM(play), QUAKE_TYPE_3);
Quake_SetSpeed(quakeIndex, 32000.0f + (Rand_ZeroOne() * 3000.0f));
Quake_SetPerturbations(quakeIndex, 10.0f - (Rand_ZeroOne() * 9.0f), 0, 0, 0);
Quake_SetDuration(quakeIndex, 48.0f - (Rand_ZeroOne() * 15.0f));
}
}