From 16f7ce1d869b08da4264788ef85ad513ec126df3 Mon Sep 17 00:00:00 2001 From: Alex Larbe Date: Fri, 31 Oct 2025 20:54:29 +0000 Subject: [PATCH 1/7] Library/Camera: Implement CameraPoserFunction --- data/file_list.yml | 210 +++--- lib/al/Library/Camera/CameraArrowCollider.h | 9 + lib/al/Library/Camera/CameraPoser.h | 12 + lib/al/Library/Camera/CameraPoserFunction.cpp | 694 ++++++++++++++++++ lib/al/Library/Camera/CameraPoserFunction.h | 397 +++++----- .../Library/Camera/CameraRequestParamHolder.h | 8 +- lib/al/Library/Camera/CameraSubTargetBase.h | 2 + .../Camera/CameraTargetCollideInfoHolder.h | 45 ++ lib/al/Library/Camera/CameraTargetHolder.h | 8 +- .../Play/Camera/CameraVerticalAbsorber.h | 16 + .../Project/Camera/CameraSubTargetTurnParam.h | 28 +- src/Player/PlayerJudgeSleep.h | 4 +- 12 files changed, 1125 insertions(+), 308 deletions(-) create mode 100644 lib/al/Library/Camera/CameraPoserFunction.cpp create mode 100644 lib/al/Library/Camera/CameraTargetCollideInfoHolder.h diff --git a/data/file_list.yml b/data/file_list.yml index f5f6c5b477..2baf0ca748 100644 --- a/data/file_list.yml +++ b/data/file_list.yml @@ -228799,19 +228799,19 @@ Library/Camera/CameraPoserFunction.o: - offset: 0x8341cc size: 12 label: _ZN21alCameraPoserFunction12getViewIndexEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8341d8 size: 12 label: _ZN21alCameraPoserFunction15getLookAtCameraEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8341e4 size: 24 label: _ZN21alCameraPoserFunction17getProjectionSeadEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8341fc size: 12 label: _ZN21alCameraPoserFunction13getProjectionEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834208 size: 24 label: _ZN21alCameraPoserFunction16getProjectionMtxEPKN2al11CameraPoserE @@ -228819,407 +228819,407 @@ Library/Camera/CameraPoserFunction.o: - offset: 0x834220 size: 8 label: _ZN21alCameraPoserFunction7getNearEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834228 size: 8 label: _ZN21alCameraPoserFunction6getFarEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834230 size: 8 label: _ZN21alCameraPoserFunction9getAspectEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834238 size: 16 label: _ZN21alCameraPoserFunction15getPreCameraPosEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834248 size: 16 label: _ZN21alCameraPoserFunction15getPreLookAtPosEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834258 size: 16 label: _ZN21alCameraPoserFunction11getPreUpDirEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834268 size: 40 label: _ZN21alCameraPoserFunction16getPreFovyDegreeEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834290 size: 12 label: _ZN21alCameraPoserFunction16getPreFovyRadianEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83429c size: 16 label: _ZN21alCameraPoserFunction17isPrePriorityDemoERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8342ac size: 16 label: _ZN21alCameraPoserFunction18isPrePriorityDemo2ERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8342bc size: 16 label: _ZN21alCameraPoserFunction21isPrePriorityDemoTalkERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8342cc size: 20 label: _ZN21alCameraPoserFunction20isPrePriorityDemoAllERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8342e0 size: 28 label: _ZN21alCameraPoserFunction24isPrePriorityEntranceAllERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8342fc size: 16 label: _ZN21alCameraPoserFunction19isPrePriorityPlayerERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x83430c size: 28 label: _ZN21alCameraPoserFunction20isEqualPreCameraNameERKN2al15CameraStartInfoEPKc - status: NotDecompiled + status: Matching - offset: 0x834328 size: 56 label: _ZN21alCameraPoserFunction22isPreCameraFixAbsoluteERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834360 size: 8 label: _ZN21alCameraPoserFunction25isInvalidCollidePreCameraERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834368 size: 8 label: _ZN21alCameraPoserFunction30isInvalidKeepPreCameraDistanceERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834370 size: 8 label: _ZN21alCameraPoserFunction41isInvalidKeepPreCameraDistanceIfNoCollideERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834378 size: 8 label: _ZN21alCameraPoserFunction25isValidResetPreCameraPoseERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834380 size: 8 label: _ZN21alCameraPoserFunction28isValidKeepPreSelfCameraPoseERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834388 size: 8 label: _ZN21alCameraPoserFunction23getPreCameraSwingAngleHERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834390 size: 8 label: _ZN21alCameraPoserFunction23getPreCameraSwingAngleVERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x834398 size: 8 label: _ZN21alCameraPoserFunction26getPreCameraMaxSwingAngleHERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343a0 size: 8 label: _ZN21alCameraPoserFunction26getPreCameraMaxSwingAngleVERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343a8 size: 8 label: _ZN21alCameraPoserFunction17isExistAreaAngleHERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343b0 size: 8 label: _ZN21alCameraPoserFunction17isExistAreaAngleVERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343b8 size: 8 label: _ZN21alCameraPoserFunction13getAreaAngleHERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343c0 size: 8 label: _ZN21alCameraPoserFunction13getAreaAngleVERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343c8 size: 8 label: _ZN21alCameraPoserFunction26isExistNextPoseByPreCameraERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343d0 size: 8 label: _ZN21alCameraPoserFunction24getNextAngleHByPreCameraERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343d8 size: 8 label: _ZN21alCameraPoserFunction24getNextAngleVByPreCameraERKN2al15CameraStartInfoE - status: NotDecompiled + status: Matching - offset: 0x8343e0 size: 148 label: _ZN21alCameraPoserFunction14calcCameraPoseEPN4sead4QuatIfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834474 size: 108 label: _ZN21alCameraPoserFunction11calcLookDirEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8344e0 size: 52 label: _ZN21alCameraPoserFunction13calcCameraDirEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834514 size: 92 label: _ZN21alCameraPoserFunction14calcCameraDirHEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834570 size: 128 label: _ZN21alCameraPoserFunction12calcLookDirHEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8345f0 size: 152 label: _ZN21alCameraPoserFunction11calcSideDirEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834688 size: 60 label: _ZN21alCameraPoserFunction16calcPreCameraDirEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8346c4 size: 104 label: _ZN21alCameraPoserFunction17calcPreCameraDirHEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83472c size: 116 label: _ZN21alCameraPoserFunction14calcPreLookDirEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8347a0 size: 92 label: _ZN21alCameraPoserFunction15calcPreLookDirHEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8347fc size: 136 label: _ZN21alCameraPoserFunction19calcPreCameraAngleHEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834884 size: 176 label: _ZN21alCameraPoserFunction19calcPreCameraAngleVEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834934 size: 92 label: _ZN21alCameraPoserFunction20setLookAtPosToTargetEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834990 size: 64 label: _ZN21alCameraPoserFunction15calcTargetTransEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8349d0 size: 120 label: _ZN21alCameraPoserFunction29setLookAtPosToTargetAddOffsetEPN2al11CameraPoserERKN4sead7Vector3IfEE - status: NotDecompiled + status: Matching - offset: 0x834a48 size: 92 label: _ZN21alCameraPoserFunction20setCameraPosToTargetEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834aa4 size: 120 label: _ZN21alCameraPoserFunction29setCameraPosToTargetAddOffsetEPN2al11CameraPoserERKN4sead7Vector3IfEE - status: NotDecompiled + status: Matching - offset: 0x834b1c size: 132 label: _ZN21alCameraPoserFunction25calcTargetTransWithOffsetEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834ba0 size: 64 label: _ZN21alCameraPoserFunction18calcTargetVelocityEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834be0 size: 152 label: _ZN21alCameraPoserFunction19calcTargetVelocityHEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834c78 size: 64 label: _ZN21alCameraPoserFunction12calcTargetUpEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834cb8 size: 232 label: _ZN21alCameraPoserFunction16calcTargetSpeedVEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834da0 size: 144 label: _ZN21alCameraPoserFunction14calcTargetPoseEPN4sead4QuatIfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834e30 size: 64 label: _ZN21alCameraPoserFunction15calcTargetFrontEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834e70 size: 64 label: _ZN21alCameraPoserFunction14calcTargetSideEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834eb0 size: 64 label: _ZN21alCameraPoserFunction17calcTargetGravityEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834ef0 size: 184 label: _ZN21alCameraPoserFunction16calcTargetSpeedHEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834fa8 size: 248 label: _ZN21alCameraPoserFunction19calcTargetJumpSpeedEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8350a0 size: 248 label: _ZN21alCameraPoserFunction19calcTargetFallSpeedEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835198 size: 40 label: _ZN21alCameraPoserFunction14isChangeTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8351c0 size: 108 label: _ZN21alCameraPoserFunction27tryGetTargetRequestDistanceEPfPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83522c size: 16 label: _ZN21alCameraPoserFunction23tryGetBossDistanceCurveEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83523c size: 16 label: _ZN21alCameraPoserFunction28tryGetEquipmentDistanceCurveEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83524c size: 16 label: _ZN21alCameraPoserFunction27isExistCollisionUnderTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83525c size: 16 label: _ZN21alCameraPoserFunction26getUnderTargetCollisionPosEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83526c size: 16 label: _ZN21alCameraPoserFunction29getUnderTargetCollisionNormalEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83527c size: 40 label: _ZN21alCameraPoserFunction32isExistSlopeCollisionUnderTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8352a4 size: 12 label: _ZN21alCameraPoserFunction31isExistWallCollisionUnderTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8352b0 size: 20 label: _ZN21alCameraPoserFunction34tryCalcSlopeCollisionDownFrontDirHEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8352c4 size: 16 label: _ZN21alCameraPoserFunction24getSlopeCollisionUpSpeedEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8352d4 size: 16 label: _ZN21alCameraPoserFunction26getSlopeCollisionDownSpeedEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8352e4 size: 32 label: _ZN21alCameraPoserFunction16isExistSubTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835304 size: 504 label: _ZN21alCameraPoserFunction25checkValidTurnToSubTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8354fc size: 84 label: _ZN21alCameraPoserFunction17calcSubTargetBackEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835550 size: 52 label: _ZN21alCameraPoserFunction18calcSubTargetTransEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835584 size: 32 label: _ZN21alCameraPoserFunction17isChangeSubTargetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8355a4 size: 52 label: _ZN21alCameraPoserFunction18calcSubTargetFrontEPN4sead7Vector3IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8355d8 size: 32 label: _ZN21alCameraPoserFunction27getSubTargetRequestDistanceEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8355f8 size: 32 label: _ZN21alCameraPoserFunction26getSubTargetTurnSpeedRate1EPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835618 size: 32 label: _ZN21alCameraPoserFunction26getSubTargetTurnSpeedRate2EPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835638 size: 32 label: _ZN21alCameraPoserFunction27getSubTargetTurnRestartStepEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835658 size: 296 label: _ZN21alCameraPoserFunction37tryCalcSubTargetTurnBrakeDistanceRateEPfPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835780 size: 32 label: _ZN21alCameraPoserFunction21isValidSubTargetTurnVEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8357a0 size: 32 label: _ZN21alCameraPoserFunction31isValidSubTargetResetAfterTurnVEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8357c0 size: 84 label: _ZN21alCameraPoserFunction29clampAngleSubTargetTurnRangeVEPfPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835814 size: 56 label: _ZN21alCameraPoserFunction26initCameraVerticalAbsorberEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83584c size: 56 label: _ZN21alCameraPoserFunction43initCameraVerticalAbsorberNoCameraPosAbsorbEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835884 size: 12 label: _ZN21alCameraPoserFunction28getCameraVerticalAbsorbPosUpEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835890 size: 12 label: _ZN21alCameraPoserFunction30getCameraVerticalAbsorbPosDownEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83589c size: 8 label: _ZN21alCameraPoserFunction22liberateVerticalAbsorbEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8358a4 size: 16 label: _ZN21alCameraPoserFunction24stopUpdateVerticalAbsorbEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8358b4 size: 20 label: _ZN21alCameraPoserFunction39stopUpdateVerticalAbsorbForSnapShotModeEPN2al11CameraPoserERKN4sead7Vector3IfEE - status: NotDecompiled + status: Matching - offset: 0x8358c8 size: 12 label: _ZN21alCameraPoserFunction27restartUpdateVerticalAbsorbEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8358d4 size: 16 label: _ZN21alCameraPoserFunction33validateVerticalAbsorbKeepInFrameEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8358e4 size: 12 label: _ZN21alCameraPoserFunction35invalidateVerticalAbsorbKeepInFrameEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8358f0 size: 12 label: _ZN21alCameraPoserFunction42setVerticalAbsorbKeepInFrameScreenOffsetUpEPN2al11CameraPoserEf - status: NotDecompiled + status: Matching - offset: 0x8358fc size: 12 label: _ZN21alCameraPoserFunction44setVerticalAbsorbKeepInFrameScreenOffsetDownEPN2al11CameraPoserEf - status: NotDecompiled + status: Matching - offset: 0x835908 size: 76 label: _ZN21alCameraPoserFunction23initCameraArrowColliderEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835954 size: 84 label: _ZN21alCameraPoserFunction50initCameraArrowColliderWithoutThroughPassCollisionEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8359a8 size: 36 label: _ZN21alCameraPoserFunction19initCameraMoveLimitEPN2al11CameraPoserE diff --git a/lib/al/Library/Camera/CameraArrowCollider.h b/lib/al/Library/Camera/CameraArrowCollider.h index ad8e90f02f..57afa9bb19 100644 --- a/lib/al/Library/Camera/CameraArrowCollider.h +++ b/lib/al/Library/Camera/CameraArrowCollider.h @@ -28,5 +28,14 @@ class CameraArrowCollider : public NerveExecutor, public IUseCollision { bool isShrink() const; f32 getPushLength() const; + + void set_48c(bool idx) { _48c = idx; } + +private: + char mBuffer[0x474]; + bool _48c; + char mBuffer2[0x3]; }; + +static_assert(sizeof(CameraArrowCollider) == 0x490); } // namespace al diff --git a/lib/al/Library/Camera/CameraPoser.h b/lib/al/Library/Camera/CameraPoser.h index cb2e167c2e..3ef23728c3 100644 --- a/lib/al/Library/Camera/CameraPoser.h +++ b/lib/al/Library/Camera/CameraPoser.h @@ -221,6 +221,14 @@ class CameraPoser : public HioNode, CameraViewInfo* getViewInfo() const { return mViewInfo; } + CameraViewInfo* getCameraViewInfo() const { return mViewInfo; } + + CameraOffsetCtrlPreset* getCameraOffsetCtrlPreset() const { return mOffsetCtrlPreset; } + + CameraPoserSceneInfo* getCameraPoserSceneInfo() const { return mSceneInfo; } + + CameraVerticalAbsorber* getCameraVerticalAbsorber() const { return mVerticalAbsorber; } + // set void setEye(const sead::Vector3f& pos) { mEye.set(pos); } @@ -234,6 +242,10 @@ class CameraPoser : public HioNode, void setFovyDegree(f32 fovy) { mFovyDegree = fovy; } + void setVerticalAbsorber(CameraVerticalAbsorber* cameraVerticalAbsorber) { + mVerticalAbsorber = cameraVerticalAbsorber; + } + protected: const char* mPoserName; ActiveState mActiveState = ActiveState::Start; diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp new file mode 100644 index 0000000000..f65d9e9446 --- /dev/null +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -0,0 +1,694 @@ +#include "Library/Camera/CameraPoserFunction.h" + +#include "Library/Base/StringUtil.h" +#include "Library/Camera/CameraArrowCollider.h" +#include "Library/Camera/CameraOffsetCtrlPreset.h" +#include "Library/Camera/CameraPoser.h" +#include "Library/Camera/CameraPoserFix.h" +#include "Library/Camera/CameraPoserSceneInfo.h" +#include "Library/Camera/CameraRequestParamHolder.h" +#include "Library/Camera/CameraStartInfo.h" +#include "Library/Camera/CameraSubTargetBase.h" +#include "Library/Camera/CameraTargetBase.h" +#include "Library/Camera/CameraTargetCollideInfoHolder.h" +#include "Library/Camera/CameraTargetHolder.h" +#include "Library/Camera/CameraViewInfo.h" +#include "Library/Math/MathUtil.h" +#include "Library/Play/Camera/CameraVerticalAbsorber.h" +#include "Library/Projection/Projection.h" +#include "Project/Camera/CameraSubTargetTurnParam.h" + +namespace alCameraPoserFunction { + +s32 getViewIndex(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getIndex(); +} + +const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getLookAtCam(); +} + +const sead::Projection& getProjectionSead(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getProjectionSead(); +} + +const al::Projection& getProjection(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getProjection(); +} + +f32 getNear(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getNear(); +} + +f32 getFar(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getFar(); +} + +f32 getAspect(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getAspect(); +} + +const sead::Vector3f& getPreCameraPos(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getLookAtCam().getPos(); +} + +const sead::Vector3f& getPreLookAtPos(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getLookAtCam().getAt(); +} + +const sead::Vector3f& getPreUpDir(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getLookAtCam().getUp(); +} + +f32 getPreFovyDegree(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getProjection().getFovy() * 57.29578f; +} + +f32 getPreFovyRadian(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getProjection().getFovy(); +} + +bool isPrePriorityDemo(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Demo; +} + +bool isPrePriorityDemo2(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Demo2; +} + +bool isPrePriorityDemoTalk(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_DemoTalk; +} + +bool isPrePriorityDemoAll(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Demo || + cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Demo2; +} + +bool isPrePriorityEntranceAll(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Entrance || + cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Unknown; +} + +bool isPrePriorityPlayer(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Player; +} + +bool isEqualPreCameraName(const al::CameraStartInfo& cameraStartInfo, const char* cameraName) { + if (cameraStartInfo.preCameraName) + return al::isEqualString(cameraName, cameraStartInfo.preCameraName); + return false; +} + +bool isPreCameraFixAbsolute(const al::CameraStartInfo& cameraStartInfo) { + const char* cameraName = al::CameraPoserFix::getFixAbsoluteCameraName(); + if (cameraStartInfo.preCameraName) + return al::isEqualString(cameraName, cameraStartInfo.preCameraName); + return false; +} + +bool isInvalidCollidePreCamera(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isInvalidCollidePreCamera; +} + +bool isInvalidKeepPreCameraDistance(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isInvalidKeepPreCameraDistance; +} + +bool isInvalidKeepPreCameraDistanceIfNoCollide(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isInvalidKeepPreCameraDistanceIfNoCollide; +} + +bool isValidResetPreCameraPose(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isValidResetPreCameraPose; +} + +bool isValidKeepPreSelfCameraPose(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isValidKeepPreSelfCameraPose; +} + +f32 getPreCameraSwingAngleH(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.preCameraSwingAngleH; +} + +f32 getPreCameraSwingAngleV(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.preCameraSwingAngleV; +} + +f32 getPreCameraMaxSwingAngleH(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.preCameraMaxSwingAngleH; +} + +f32 getPreCameraMaxSwingAngleV(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.preCameraMaxSwingAngleV; +} + +bool isExistAreaAngleH(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isExistAreaAngleH; +} + +bool isExistAreaAngleV(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isExistAreaAngleV; +} + +f32 getAreaAngleH(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.areaAngleH; +} + +f32 getAreaAngleV(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.areaAngleV; +} + +bool isExistNextPoseByPreCamera(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.isExistNextPoseByPreCamera; +} + +f32 getNextAngleHByPreCamera(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.nextAngleHByPreCamera; +} + +f32 getNextAngleVByPreCamera(const al::CameraStartInfo& cameraStartInfo) { + return cameraStartInfo.nextAngleVByPreCamera; +} + +void calcCameraPose(sead::Quatf* out, const al::CameraPoser* cameraPoser) { + sead::Vector3f vec; + vec.x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; + vec.y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; + vec.z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + + al::normalize(&vec); + vec.negate(); + al::makeQuatFrontUp(out, vec, cameraPoser->getCameraUp()); +} + +void calcLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; + out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; + out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + al::normalize(out); + out->negate(); +} + +void calcCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; + out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; + out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + al::normalize(out); +} + +void calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; + out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; + out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + al::verticalizeVec(out, cameraPoser->getCameraUp(), *out); + al::tryNormalizeOrZero(out); +} + +bool calcLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; + out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; + out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + al::verticalizeVec(out, cameraPoser->getCameraUp(), *out); + bool ret = al::tryNormalizeOrZero(out); + out->negate(); + return ret; +} + +void calcSideDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = cameraPoser->getPosition() - cameraPoser->getTargetTrans(); + al::normalize(&vec); + *out = vec.cross(cameraPoser->getCameraUp()); + al::normalize(out); +} + +void calcPreCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); + out->x = lookAtCam.getPos().x - lookAtCam.getAt().x; + out->y = lookAtCam.getPos().y - lookAtCam.getAt().y; + out->z = lookAtCam.getPos().z - lookAtCam.getAt().z; + al::normalize(out); +} + +void calcPreCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); + out->x = lookAtCam.getPos().x - lookAtCam.getAt().x; + out->y = lookAtCam.getPos().y - lookAtCam.getAt().y; + out->z = lookAtCam.getPos().z - lookAtCam.getAt().z; + al::verticalizeVec(out, sead::Vector3f::ey, *out); + al::tryNormalizeOrZero(out); +} + +void calcPreLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); + out->x = lookAtCam.getPos().x - lookAtCam.getAt().x; + out->y = lookAtCam.getPos().y - lookAtCam.getAt().y; + out->z = lookAtCam.getPos().z - lookAtCam.getAt().z; + al::normalize(out); + out->negate(); +} + +void calcPreLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); + out->set(lookAtCam.getAt() - lookAtCam.getPos()); + al::verticalizeVec(out, cameraPoser->getCameraViewInfo()->getLookAtCam().getUp(), *out); + al::tryNormalizeOrZero(out); +} + +f32 calcPreCameraAngleH(const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + calcPreCameraDirH(&vec, cameraPoser); + return sead::Mathf::atan2(vec.x, vec.z) * 57.29578f; +} + +f32 calcPreCameraAngleV(const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + calcPreCameraDir(&vec, cameraPoser); + al::parallelizeVec(&vec, sead::Vector3f::ey, vec); + return sead::Mathf::asin(sead::Mathf::sqrt(vec.dot(vec))) * 57.29578f; +} + +void setLookAtPosToTarget(al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + calcTargetTrans(&vec, cameraPoser); + cameraPoser->setTargetTrans(vec); +} + +void calcTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + cameraTargetBase->calcTrans(out); +} + +void setLookAtPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset) { + sead::Vector3f vec = {0, 0, 0}; + calcTargetTrans(&vec, cameraPoser); + cameraPoser->setTargetTrans(vec + offset); +} + +void setCameraPosToTarget(al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + calcTargetTrans(&vec, cameraPoser); + cameraPoser->setPosition(vec); +} + +void setCameraPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset) { + sead::Vector3f vec = {0, 0, 0}; + calcTargetTrans(&vec, cameraPoser); + cameraPoser->setPosition(vec + offset); +} + +void calcTargetTransWithOffset(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + calcTargetTrans(out, cameraPoser); + al::CameraOffsetCtrlPreset* cameraOffsetCtrlPreset = cameraPoser->getCameraOffsetCtrlPreset(); + if (cameraOffsetCtrlPreset) + out->add(cameraOffsetCtrlPreset->getOffset()); +} + +void calcTargetVelocity(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + cameraTargetBase->calcVelocity(out); +} + +void calcTargetVelocityH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + calcTargetVelocity(out, cameraPoser); + sead::Vector3f vec = sead::Vector3f::ey; + calcTargetUp(&vec, cameraPoser); + al::verticalizeVec(out, vec, *out); +} + +void calcTargetUp(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + cameraTargetBase->calcUp(out); +} + +f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec2 = {0, 0, 0}; + calcTargetVelocity(&vec, cameraPoser); + calcTargetUp(&vec2, cameraPoser); + al::parallelizeVec(&vec, vec2, vec); + + f32 dot = vec.dot(vec2); + f32 sqrtDot = sead::Mathf::sqrt(vec.dot(vec)); + if (!(dot > 0.0f)) + sqrtDot = -sqrtDot; + return sqrtDot; +} + +void calcTargetPose(sead::Quatf* out, const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec2 = {0, 0, 0}; + calcTargetUp(&vec, cameraPoser); + calcTargetFront(&vec2, cameraPoser); + al::makeQuatFrontUp(out, vec2, vec); +} + +void calcTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + cameraTargetBase->calcFront(out); +} + +void calcTargetSide(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + cameraTargetBase->calcSide(out); +} + +void calcTargetGravity(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + cameraTargetBase->calcGravity(out); +} + +f32 calcTargetSpeedH(const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec2 = {0, 0, 0}; + calcTargetGravity(&vec, cameraPoser); + calcTargetVelocity(&vec2, cameraPoser); + al::verticalizeVec(&vec2, vec, vec2); + return sead::Mathf::sqrt(vec2.dot(vec2)); +} + +f32 calcTargetJumpSpeed(const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec2 = {0, 0, 0}; + calcTargetGravity(&vec, cameraPoser); + calcTargetVelocity(&vec2, cameraPoser); + al::parallelizeVec(&vec2, vec, vec2); + if (!al::isNearZero(vec2, 0.001f) && !(vec.dot(vec2) > 0.0f)) + return sead::Mathf::sqrt(vec2.dot(vec2)); + return 0.0f; +} + +f32 calcTargetFallSpeed(const al::CameraPoser* cameraPoser) { + sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec2 = {0, 0, 0}; + calcTargetGravity(&vec, cameraPoser); + calcTargetVelocity(&vec2, cameraPoser); + al::parallelizeVec(&vec2, vec, vec2); + if (!al::isNearZero(vec2, 0.001f) && !(vec.dot(vec2) < 0.0f)) + return sead::Mathf::sqrt(vec2.dot(vec2)); + return 0.0f; +} + +bool isChangeTarget(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + return cameraTargetHolder->isChangeViewTarget(cameraPoser->getViewInfo()->getIndex()); +} + +bool tryGetTargetRequestDistance(f32* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraTargetBase* cameraTargetBase = + cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); + f32 requestDistance = cameraTargetBase->getRequestDistance(); + if (requestDistance > 0.0) { + *out = cameraTargetBase->getRequestDistance(); + return true; + } + return false; +} + +f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo()->requestParamHolder->get_60(); +} + +f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo()->requestParamHolder->get_58(); +} + +bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo() + ->targetCollideInfoHolder->isExistCollisionUnderTarget(); +} + +const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder->getTargetCollisionPos(); +} + +const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo() + ->targetCollideInfoHolder->getTargetCollisionNormal(); +} + +bool isExistSlopeCollisionUnderTarget(const al::CameraPoser* cameraPoser) { + al::CameraTargetCollideInfoHolder* cameraTargetCollideInfoHolder = + cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; + if (cameraTargetCollideInfoHolder->isExistCollisionUnderTarget()) + return cameraTargetCollideInfoHolder->isExistSlopeCollisionUnderTarget(); + return false; +} + +bool isExistWallCollisionUnderTarget(const al::CameraPoser* cameraPoser) { + al::CameraTargetCollideInfoHolder* cameraTargetCollideInfoHolder = + cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; + return cameraTargetCollideInfoHolder->isExistUnderWall(); +} + +bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetCollideInfoHolder* cameraTargetCollideInfoHolder = + cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; + return cameraTargetCollideInfoHolder->tryCalcSlopDownFrontDirH(out); +} + +f32 getSlopeCollisionUpSpeed(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo() + ->targetCollideInfoHolder->getSlopeCollisionUpSpeed(); +} + +f32 getSlopeCollisionDownSpeed(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo() + ->targetCollideInfoHolder->getSlopeCollisionDownSpeed(); +} + +bool isExistSubTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getTargetHolder()->getTopSubTargetInline(); +} + +bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser) { + if (!cameraPoser->getTargetHolder()->getTopSubTargetInline()) + return false; + al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* topSubTarget = cameraTargetHolder->getTopSubTarget(); + al::CameraSubTargetTurnParam* subTargetTurnParam = topSubTarget->getSubTargetTurnParam(); + if (subTargetTurnParam->getValidTurnDegreeRangeH() < 0.0f && + subTargetTurnParam->getValidFaceDegreeRangeH() != 0.0f) { + return true; + } + sead::Vector3f vec = {}; + vec.x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; + vec.y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; + vec.z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + al::verticalizeVec(&vec, cameraPoser->getCameraUp(), vec); + bool ret = al::tryNormalizeOrZero(&vec); + vec.negate(); + if (!ret) + return false; + if (subTargetTurnParam->getValidFaceDegreeRangeH() >= 0.0f) { + sead::Vector3f vec2 = {0, 0, 0}; + calcSubTargetBack(&vec2, cameraPoser); + f32 validFaceDegreeRangeH = subTargetTurnParam->getValidFaceDegreeRangeH(); + f32 angleDegree = al::calcAngleDegree(vec2, vec); + if (validFaceDegreeRangeH < angleDegree) + return false; + } + if (subTargetTurnParam->getValidTurnDegreeRangeH() >= 0.0f) { + sead::Vector3f vec2 = {0, 0, 0}; + sead::Vector3f vec3 = {0, 0, 0}; + calcSubTargetTrans(&vec2, cameraPoser); + vec3 = vec2 - cameraPoser->getPosition(); + al::verticalizeVec(&vec3, cameraPoser->getCameraUp(), vec3); + if (!al::tryNormalizeOrZero(&vec3)) + return false; + if (subTargetTurnParam->getValidTurnDegreeRangeH() / 2 < al::calcAngleDegree(vec, vec3)) + return false; + } + return true; +} + +void calcSubTargetBack(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + calcSubTargetFront(out, cameraPoser); + out->negate(); +} + +void calcSubTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + subTargetBase->calcTrans(out); +} + +bool isChangeSubTarget(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + return targetHolder->hasTopSubTargetChanged(); +} + +void calcSubTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + subTargetBase->calcFront(out); +} + +f32 getSubTargetRequestDistance(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + return subTargetBase->getRequestDistance(); +} + +f32 getSubTargetTurnSpeedRate1(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + return subTargetBase->getSubTargetTurnParam()->getTurnSpeedRate1(); +} + +f32 getSubTargetTurnSpeedRate2(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + return subTargetBase->getSubTargetTurnParam()->getTurnSpeedRate2(); +} + +s32 getSubTargetTurnRestartStep(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + return subTargetBase->getSubTargetTurnParam()->getTargetTurnRestartStep(); +} + +bool tryCalcSubTargetTurnBrakeDistanceRate(f32* out, const al::CameraPoser* cameraPoser) { + al::CameraSubTargetBase* subTargetBase = cameraPoser->getTargetHolder()->getTopSubTarget(); + al::CameraSubTargetTurnParam* turnParam = subTargetBase->getSubTargetTurnParam(); + + sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec2 = {0, 0, 0}; + calcTargetTrans(&vec, cameraPoser); + calcSubTargetTrans(&vec2, cameraPoser); + + f32 distance = sead::Mathf::sqrt(sead::Mathf::pow(vec.x - vec2.x, 2) + + sead::Mathf::pow(vec.z - vec2.z, 2)); + + f32 turnBrakeDistance = turnParam->getTurnBrakeEndDistance(); + if (turnBrakeDistance > 0.0f) { + f32 turnBrakeStartDistance = turnParam->getTurnBrakeStartDistance(); + if (turnBrakeDistance < turnBrakeStartDistance && distance < turnBrakeStartDistance) { + *out = 1.0f - al::normalize(distance, turnBrakeDistance, turnBrakeStartDistance); + return true; + } + } + + f32 turnStopStartDistance = turnParam->getTurnStopStartDistance(); + if (turnStopStartDistance > 0.0f) { + f32 turnStopEndDistance = turnParam->getTurnStopEndDistance(); + if (turnStopStartDistance < turnStopEndDistance && turnStopStartDistance < distance) { + *out = al::normalize(distance, turnStopStartDistance, turnStopEndDistance); + return true; + } + } + + return false; +} + +bool isValidSubTargetTurnV(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + return subTargetBase->getSubTargetTurnParam()->isTurnV(); +} + +bool isValidSubTargetResetAfterTurnV(const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); + return subTargetBase->getSubTargetTurnParam()->isResetAfterTurnV(); +} + +void clampAngleSubTargetTurnRangeV(f32* out, const al::CameraPoser* cameraPoser) { + al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); + al::CameraSubTargetBase* topSubTarget = targetHolder->getTopSubTarget(); + f32 minTurnDegree = topSubTarget->getSubTargetTurnParam()->getMinTurnDegreeV(); + f32 maxTurnDegree = 0.0f; + + f32 outParam = *out; + if (!(outParam < minTurnDegree)) { + maxTurnDegree = topSubTarget->getSubTargetTurnParam()->getMaxTurnDegreeV(); + minTurnDegree = outParam; + if (outParam > maxTurnDegree) + minTurnDegree = maxTurnDegree; + } + *out = minTurnDegree; +} + +void initCameraVerticalAbsorber(al::CameraPoser* cameraPoser) { + al::CameraVerticalAbsorber* cameraVerticalAbsorber = + new al::CameraVerticalAbsorber(cameraPoser, false); + cameraPoser->setVerticalAbsorber(cameraVerticalAbsorber); +} + +void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser* cameraPoser) { + al::CameraVerticalAbsorber* cameraVerticalAbsorber = + new al::CameraVerticalAbsorber(cameraPoser, true); + cameraPoser->setVerticalAbsorber(cameraVerticalAbsorber); +} + +f32 getCameraVerticalAbsorbPosUp(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraVerticalAbsorber()->getAbsorbScreenPosUp(); +} + +f32 getCameraVerticalAbsorbPosDown(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraVerticalAbsorber()->getAbsorbScreenPosDown(); +} + +void liberateVerticalAbsorb(al::CameraPoser* cameraPoser) { + cameraPoser->getCameraVerticalAbsorber()->liberateAbsorb(); +} + +void stopUpdateVerticalAbsorb(al::CameraPoser* cameraPoser) { + cameraPoser->getCameraVerticalAbsorber()->setIsStopUpdate(true); +} + +void stopUpdateVerticalAbsorbForSnapShotMode(al::CameraPoser* cameraPoser, + const sead::Vector3f& absorbVec) { + stopUpdateVerticalAbsorb(cameraPoser); + cameraPoser->getCameraVerticalAbsorber()->tryResetAbsorbVecIfInCollision(absorbVec); +} + +void restartUpdateVerticalAbsorb(al::CameraPoser* cameraPoser) { + cameraPoser->getCameraVerticalAbsorber()->setIsStopUpdate(false); +} + +void validateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser) { + cameraPoser->getCameraVerticalAbsorber()->setIsKeepInFrame(true); +} + +void invalidateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser) { + cameraPoser->getCameraVerticalAbsorber()->setIsKeepInFrame(false); +} + +void setVerticalAbsorbKeepInFrameScreenOffsetUp(al::CameraPoser* cameraPoser, + f32 keepInFrameOffsetUp) { + cameraPoser->getCameraVerticalAbsorber()->setKeepInFrameOffsetUp(keepInFrameOffsetUp); +} + +void setVerticalAbsorbKeepInFrameScreenOffsetDown(al::CameraPoser* cameraPoser, + f32 keepInFrameOffsetDown) { + cameraPoser->getCameraVerticalAbsorber()->setKeepInFrameOffsetDown(keepInFrameOffsetDown); +} + +void initCameraArrowCollider(al::CameraPoser* cameraPoser) { + al::CameraArrowCollider* cameraArrowCollider = + new al::CameraArrowCollider(cameraPoser->getCollisionDirector()); + cameraPoser->initArrowCollider(cameraArrowCollider); +} + +void initCameraArrowColliderWithoutThroughPassCollision(al::CameraPoser* cameraPoser) { + al::CameraArrowCollider* cameraArrowCollider = + new al::CameraArrowCollider(cameraPoser->getCollisionDirector()); + cameraArrowCollider->set_48c(true); + cameraPoser->initArrowCollider(cameraArrowCollider); +} + +} // namespace alCameraPoserFunction diff --git a/lib/al/Library/Camera/CameraPoserFunction.h b/lib/al/Library/Camera/CameraPoserFunction.h index 25c5b6bde3..0be549b35a 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.h +++ b/lib/al/Library/Camera/CameraPoserFunction.h @@ -16,165 +16,168 @@ struct CameraStartInfo; struct CameraObjectRequestInfo; class IUseCollision; class PlacementInfo; +class Projection; } // namespace al namespace alCameraPoserFunction { class CameraCollisionHitResult; -s32 getViewIndex(const al::CameraPoser*); -sead::LookAtCamera* getLookAtCamera(const al::CameraPoser*); -sead::Projection* getProjectionSead(const al::CameraPoser*); -al::Projection* getProjection(const al::CameraPoser*); -const sead::Matrix34f& getProjectionMtx(const al::CameraPoser*); -f32 getNear(const al::CameraPoser*); -f32 getFar(const al::CameraPoser*); -f32 getAspect(const al::CameraPoser*); -const sead::Vector3f& getPreCameraPos(const al::CameraPoser*); -const sead::Vector3f& getPreLookAtPos(const al::CameraPoser*); -const sead::Vector3f& getPreUpDir(const al::CameraPoser*); -f32 getPreFovyDegree(const al::CameraPoser*); -f32 getPreFovyRadian(const al::CameraPoser*); -bool isPrePriorityDemo(const al::CameraStartInfo&); -bool isPrePriorityDemo2(const al::CameraStartInfo&); -bool isPrePriorityDemoTalk(const al::CameraStartInfo&); -bool isPrePriorityDemoAll(const al::CameraStartInfo&); -bool isPrePriorityEntranceAll(const al::CameraStartInfo&); -bool isPrePriorityPlayer(const al::CameraStartInfo&); -bool isEqualPreCameraName(const al::CameraStartInfo&, const char*); -bool isPreCameraFixAbsolute(const al::CameraStartInfo&); -bool isInvalidCollidePreCamera(const al::CameraStartInfo&); -bool isInvalidKeepPreCameraDistance(const al::CameraStartInfo&); -bool isInvalidKeepPreCameraDistanceIfNoCollide(const al::CameraStartInfo&); -bool isValidResetPreCameraPose(const al::CameraStartInfo&); -bool isValidKeepPreSelfCameraPose(const al::CameraStartInfo&); -f32 getPreCameraSwingAngleH(const al::CameraStartInfo&); -f32 getPreCameraSwingAngleV(const al::CameraStartInfo&); -f32 getPreCameraMaxSwingAngleH(const al::CameraStartInfo&); -f32 getPreCameraMaxSwingAngleV(const al::CameraStartInfo&); -bool isExistAreaAngleH(const al::CameraStartInfo&); -bool isExistAreaAngleV(const al::CameraStartInfo&); -f32 getAreaAngleH(const al::CameraStartInfo&); -f32 getAreaAngleV(const al::CameraStartInfo&); -bool isExistNextPoseByPreCamera(const al::CameraStartInfo&); -f32 getNextAngleHByPreCamera(const al::CameraStartInfo&); -f32 getNextAngleVByPreCamera(const al::CameraStartInfo&); -void calcCameraPose(sead::Quatf*, const al::CameraPoser*); -void calcLookDir(sead::Vector3f*, const al::CameraPoser*); -void calcCameraDir(sead::Vector3f*, const al::CameraPoser*); -bool calcCameraDirH(sead::Vector3f*, const al::CameraPoser*); -void calcLookDirH(sead::Vector3f*, const al::CameraPoser*); -void calcSideDir(sead::Vector3f*, const al::CameraPoser*); -void calcPreCameraDir(sead::Vector3f*, const al::CameraPoser*); -void calcPreCameraDirH(sead::Vector3f*, const al::CameraPoser*); -void calcPreLookDir(sead::Vector3f*, const al::CameraPoser*); -void calcPreLookDirH(sead::Vector3f*, const al::CameraPoser*); -void calcPreCameraAngleH(const al::CameraPoser*); -void calcPreCameraAngleV(const al::CameraPoser*); -void setLookAtPosToTarget(al::CameraPoser*); -void calcTargetTrans(sead::Vector3f*, const al::CameraPoser*); -void setLookAtPosToTargetAddOffset(al::CameraPoser*, const sead::Vector3f&); -void setCameraPosToTarget(al::CameraPoser*); -void setCameraPosToTargetAddOffset(al::CameraPoser*, const sead::Vector3f&); -void calcTargetTransWithOffset(sead::Vector3f*, const al::CameraPoser*); -void calcTargetVelocity(sead::Vector3f*, const al::CameraPoser*); -void calcTargetVelocityH(sead::Vector3f*, const al::CameraPoser*); -void calcTargetUp(sead::Vector3f*, const al::CameraPoser*); -f32 calcTargetSpeedV(const al::CameraPoser*); -void calcTargetPose(sead::Quatf*, const al::CameraPoser*); -void calcTargetFront(sead::Vector3f*, const al::CameraPoser*); -void calcTargetSide(sead::Vector3f*, const al::CameraPoser*); -void calcTargetGravity(sead::Vector3f*, const al::CameraPoser*); -f32 calcTargetSpeedH(const al::CameraPoser*); -f32 calcTargetJumpSpeed(const al::CameraPoser*); -f32 calcTargetFallSpeed(const al::CameraPoser*); -bool isChangeTarget(const al::CameraPoser*); -bool tryGetTargetRequestDistance(f32*, const al::CameraPoser*); -bool tryGetBossDistanceCurve(const al::CameraPoser*); -bool tryGetEquipmentDistanceCurve(const al::CameraPoser*); -bool isExistCollisionUnderTarget(const al::CameraPoser*); -const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser*); -const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser*); -bool isExistSlopeCollisionUnderTarget(const al::CameraPoser*); -bool isExistWallCollisionUnderTarget(const al::CameraPoser*); -bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f*, const al::CameraPoser*); -void getSlopeCollisionUpSpeed(const al::CameraPoser*); -void getSlopeCollisionDownSpeed(const al::CameraPoser*); -bool isExistSubTarget(const al::CameraPoser*); -void checkValidTurnToSubTarget(const al::CameraPoser*); -void calcSubTargetBack(sead::Vector3f*, const al::CameraPoser*); -void calcSubTargetTrans(sead::Vector3f*, const al::CameraPoser*); -bool isChangeSubTarget(const al::CameraPoser*); -void calcSubTargetFront(sead::Vector3f*, const al::CameraPoser*); -void getSubTargetRequestDistance(const al::CameraPoser*); -void getSubTargetTurnSpeedRate1(const al::CameraPoser*); -void getSubTargetTurnSpeedRate2(const al::CameraPoser*); -void getSubTargetTurnRestartStep(const al::CameraPoser*); -bool tryCalcSubTargetTurnBrakeDistanceRate(f32*, const al::CameraPoser*); -bool isValidSubTargetTurnV(const al::CameraPoser*); -bool isValidSubTargetResetAfterTurnV(const al::CameraPoser*); -void clampAngleSubTargetTurnRangeV(f32*, const al::CameraPoser*); -void initCameraVerticalAbsorber(al::CameraPoser*); -void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser*); -void getCameraVerticalAbsorbPosUp(const al::CameraPoser*); -void getCameraVerticalAbsorbPosDown(const al::CameraPoser*); -void liberateVerticalAbsorb(al::CameraPoser*); -void stopUpdateVerticalAbsorb(al::CameraPoser*); -void stopUpdateVerticalAbsorbForSnapShotMode(al::CameraPoser*, const sead::Vector3f&); -void restartUpdateVerticalAbsorb(al::CameraPoser*); -void validateVerticalAbsorbKeepInFrame(al::CameraPoser*); -void invalidateVerticalAbsorbKeepInFrame(al::CameraPoser*); -void setVerticalAbsorbKeepInFrameScreenOffsetUp(al::CameraPoser*, f32); -void setVerticalAbsorbKeepInFrameScreenOffsetDown(al::CameraPoser*, f32); -void initCameraArrowCollider(al::CameraPoser*); -void initCameraArrowColliderWithoutThroughPassCollision(al::CameraPoser*); -void initCameraMoveLimit(al::CameraPoser*); -void initCameraAngleCtrl(al::CameraPoser*); -void initCameraAngleCtrlWithRelativeH(al::CameraPoser*); -void initCameraDefaultAngleRangeV(al::CameraPoser*, f32, f32); -void setCameraStartAngleV(al::CameraPoser*, f32); -void setCameraAngleV(al::CameraPoser*, f32); -void getCameraAngleH(const al::CameraPoser*); -void getCameraAngleV(const al::CameraPoser*); -void initAngleSwing(al::CameraPoser*); -bool isValidAngleSwing(const al::CameraPoser*); -void initCameraOffsetCtrlPreset(al::CameraPoser*); -void getOffset(const al::CameraPoser*); -void initGyroCameraCtrl(al::CameraPoser*); -void resetGyro(al::CameraPoser*); -void calcCameraGyroPose(const al::CameraPoser*, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*); -void getGyroFront(al::CameraPoser*); -void getGyroAngleV(al::CameraPoser*); -void getGyroAngleH(al::CameraPoser*); -void setGyroLimitAngleV(al::CameraPoser*, f32, f32); -void setGyroSensitivity(al::CameraPoser*, f32, f32); -void reduceGyroSencitivity(al::CameraPoser*); -void stopUpdateGyro(al::CameraPoser*); -void restartUpdateGyro(al::CameraPoser*); -bool isStopUpdateGyro(const al::CameraPoser*); -bool isTargetCollideGround(const al::CameraPoser*); -bool isTargetInWater(const al::CameraPoser*); -bool isTargetInMoonGravity(const al::CameraPoser*); -bool isTargetClimbPole(const al::CameraPoser*); -bool isTargetGrabCeil(const al::CameraPoser*); -bool isTargetInvalidMoveByInput(const al::CameraPoser*); -bool isTargetEnableEndAfterInterpole(const al::CameraPoser*); -bool isTargetWallCatch(const al::CameraPoser*); -bool isSnapShotMode(const al::CameraPoser*); -void initSnapShotCameraCtrl(al::CameraPoser*); -void initSnapShotCameraCtrlZoomAutoReset(al::CameraPoser*); -void initSnapShotCameraCtrlZoomRollMove(al::CameraPoser*); -void validateSnapShotCameraLookAtOffset(al::CameraPoser*); -void validateSnapShotCameraZoomFovy(al::CameraPoser*); -void validateSnapShotCameraRoll(al::CameraPoser*); -void updateSnapShotCameraCtrl(al::CameraPoser*); -void startResetSnapShotCameraCtrl(al::CameraPoser*, s32); -void setSnapShotMaxZoomOutFovyDegree(al::CameraPoser*, f32); -void getSnapShotRollDegree(const al::CameraPoser*); -void getSnapShotLookAtOffset(const al::CameraPoser*); -bool isOffVerticalAbsorb(const al::CameraPoser*); -void onVerticalAbsorb(al::CameraPoser*); -void offVerticalAbsorb(al::CameraPoser*); -void invalidateCameraBlur(al::CameraPoser*); +s32 getViewIndex(const al::CameraPoser* cameraPoser); +const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser); +const sead::Projection& getProjectionSead(const al::CameraPoser* cameraPoser); +const al::Projection& getProjection(const al::CameraPoser* cameraPoser); +void getProjectionMtx(const al::CameraPoser* cameraPoser); +f32 getNear(const al::CameraPoser* cameraPoser); +f32 getFar(const al::CameraPoser* cameraPoser); +f32 getAspect(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getPreCameraPos(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getPreLookAtPos(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getPreUpDir(const al::CameraPoser* cameraPoser); +f32 getPreFovyDegree(const al::CameraPoser* cameraPoser); +f32 getPreFovyRadian(const al::CameraPoser* cameraPoser); +bool isPrePriorityDemo(const al::CameraStartInfo& cameraStartInfo); +bool isPrePriorityDemo2(const al::CameraStartInfo& cameraStartInfo); +bool isPrePriorityDemoTalk(const al::CameraStartInfo& cameraStartInfo); +bool isPrePriorityDemoAll(const al::CameraStartInfo& cameraStartInfo); +bool isPrePriorityEntranceAll(const al::CameraStartInfo& cameraStartInfo); +bool isPrePriorityPlayer(const al::CameraStartInfo& cameraStartInfo); +bool isEqualPreCameraName(const al::CameraStartInfo& cameraStartInfo, const char*); +bool isPreCameraFixAbsolute(const al::CameraStartInfo& cameraStartInfo); +bool isInvalidCollidePreCamera(const al::CameraStartInfo& cameraStartInfo); +bool isInvalidKeepPreCameraDistance(const al::CameraStartInfo& cameraStartInfo); +bool isInvalidKeepPreCameraDistanceIfNoCollide(const al::CameraStartInfo& cameraStartInfo); +bool isValidResetPreCameraPose(const al::CameraStartInfo& cameraStartInfo); +bool isValidKeepPreSelfCameraPose(const al::CameraStartInfo& cameraStartInfo); +f32 getPreCameraSwingAngleH(const al::CameraStartInfo& cameraStartInfo); +f32 getPreCameraSwingAngleV(const al::CameraStartInfo& cameraStartInfo); +f32 getPreCameraMaxSwingAngleH(const al::CameraStartInfo& cameraStartInfo); +f32 getPreCameraMaxSwingAngleV(const al::CameraStartInfo& cameraStartInfo); +bool isExistAreaAngleH(const al::CameraStartInfo& cameraStartInfo); +bool isExistAreaAngleV(const al::CameraStartInfo& cameraStartInfo); +f32 getAreaAngleH(const al::CameraStartInfo& cameraStartInfo); +f32 getAreaAngleV(const al::CameraStartInfo& cameraStartInfo); +bool isExistNextPoseByPreCamera(const al::CameraStartInfo& cameraStartInfo); +f32 getNextAngleHByPreCamera(const al::CameraStartInfo& cameraStartInfo); +f32 getNextAngleVByPreCamera(const al::CameraStartInfo& cameraStartInfo); +void calcCameraPose(sead::Quatf* out, const al::CameraPoser* cameraPoser); +void calcLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +bool calcLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcSideDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcPreCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcPreCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcPreLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcPreLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +f32 calcPreCameraAngleH(const al::CameraPoser* cameraPoser); +f32 calcPreCameraAngleV(const al::CameraPoser* cameraPoser); +void setLookAtPosToTarget(al::CameraPoser* cameraPoser); +void calcTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void setLookAtPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset); +void setCameraPosToTarget(al::CameraPoser* cameraPoser); +void setCameraPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset); +void calcTargetTransWithOffset(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetVelocity(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetVelocityH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetUp(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser); +void calcTargetPose(sead::Quatf* out, const al::CameraPoser* cameraPoser); +void calcTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetSide(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetGravity(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +f32 calcTargetSpeedH(const al::CameraPoser* cameraPoser); +f32 calcTargetJumpSpeed(const al::CameraPoser* cameraPoser); +f32 calcTargetFallSpeed(const al::CameraPoser* cameraPoser); +bool isChangeTarget(const al::CameraPoser* cameraPoser); +bool tryGetTargetRequestDistance(f32* out, const al::CameraPoser* cameraPoser); +f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser); +f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser); +bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser* cameraPoser); +bool isExistSlopeCollisionUnderTarget(const al::CameraPoser* cameraPoser); +bool isExistWallCollisionUnderTarget(const al::CameraPoser* cameraPoser); +bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +f32 getSlopeCollisionUpSpeed(const al::CameraPoser* cameraPoser); +f32 getSlopeCollisionDownSpeed(const al::CameraPoser* cameraPoser); +bool isExistSubTarget(const al::CameraPoser* cameraPoser); +bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser); +void calcSubTargetBack(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcSubTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +bool isChangeSubTarget(const al::CameraPoser* cameraPoser); +void calcSubTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +f32 getSubTargetRequestDistance(const al::CameraPoser* cameraPoser); +f32 getSubTargetTurnSpeedRate1(const al::CameraPoser* cameraPoser); +f32 getSubTargetTurnSpeedRate2(const al::CameraPoser* cameraPoser); +s32 getSubTargetTurnRestartStep(const al::CameraPoser* cameraPoser); +bool tryCalcSubTargetTurnBrakeDistanceRate(f32* out, const al::CameraPoser* cameraPoser); +bool isValidSubTargetTurnV(const al::CameraPoser* cameraPoser); +bool isValidSubTargetResetAfterTurnV(const al::CameraPoser* cameraPoser); +void clampAngleSubTargetTurnRangeV(f32* out, const al::CameraPoser* cameraPoser); +void initCameraVerticalAbsorber(al::CameraPoser* cameraPoser); +void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser* cameraPoser); +f32 getCameraVerticalAbsorbPosUp(const al::CameraPoser* cameraPoser); +f32 getCameraVerticalAbsorbPosDown(const al::CameraPoser* cameraPoser); +void liberateVerticalAbsorb(al::CameraPoser* cameraPoser); +void stopUpdateVerticalAbsorb(al::CameraPoser* cameraPoser); +void stopUpdateVerticalAbsorbForSnapShotMode(al::CameraPoser* cameraPoser, + const sead::Vector3f& offset); +void restartUpdateVerticalAbsorb(al::CameraPoser* cameraPoser); +void validateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser); +void invalidateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser); +void setVerticalAbsorbKeepInFrameScreenOffsetUp(al::CameraPoser* cameraPoser, f32 offset); +void setVerticalAbsorbKeepInFrameScreenOffsetDown(al::CameraPoser* cameraPoser, f32 offset); +void initCameraArrowCollider(al::CameraPoser* cameraPoser); +void initCameraArrowColliderWithoutThroughPassCollision(al::CameraPoser* cameraPoser); +void initCameraMoveLimit(al::CameraPoser* cameraPoser); +void initCameraAngleCtrl(al::CameraPoser* cameraPoser); +void initCameraAngleCtrlWithRelativeH(al::CameraPoser* cameraPoser); +void initCameraDefaultAngleRangeV(al::CameraPoser* cameraPoser, f32 min, f32 max); +void setCameraStartAngleV(al::CameraPoser* cameraPoser, f32 angle); +void setCameraAngleV(al::CameraPoser* cameraPoser, f32 angle); +void getCameraAngleH(const al::CameraPoser* cameraPoser); +void getCameraAngleV(const al::CameraPoser* cameraPoser); +void initAngleSwing(al::CameraPoser* cameraPoser); +bool isValidAngleSwing(const al::CameraPoser* cameraPoser); +void initCameraOffsetCtrlPreset(al::CameraPoser* cameraPoser); +void getOffset(const al::CameraPoser* cameraPoser); +void initGyroCameraCtrl(al::CameraPoser* cameraPoser); +void resetGyro(al::CameraPoser* cameraPoser); +void calcCameraGyroPose(const al::CameraPoser* cameraPoser, sead::Vector3f*, sead::Vector3f*, + sead::Vector3f*); +void getGyroFront(al::CameraPoser* cameraPoser); +void getGyroAngleV(al::CameraPoser* cameraPoser); +void getGyroAngleH(al::CameraPoser* cameraPoser); +void setGyroLimitAngleV(al::CameraPoser* cameraPoser, f32, f32); +void setGyroSensitivity(al::CameraPoser* cameraPoser, f32, f32); +void reduceGyroSencitivity(al::CameraPoser* cameraPoser); +void stopUpdateGyro(al::CameraPoser* cameraPoser); +void restartUpdateGyro(al::CameraPoser* cameraPoser); +bool isStopUpdateGyro(const al::CameraPoser* cameraPoser); +bool isTargetCollideGround(const al::CameraPoser* cameraPoser); +bool isTargetInWater(const al::CameraPoser* cameraPoser); +bool isTargetInMoonGravity(const al::CameraPoser* cameraPoser); +bool isTargetClimbPole(const al::CameraPoser* cameraPoser); +bool isTargetGrabCeil(const al::CameraPoser* cameraPoser); +bool isTargetInvalidMoveByInput(const al::CameraPoser* cameraPoser); +bool isTargetEnableEndAfterInterpole(const al::CameraPoser* cameraPoser); +bool isTargetWallCatch(const al::CameraPoser* cameraPoser); +bool isSnapShotMode(const al::CameraPoser* cameraPoser); +void initSnapShotCameraCtrl(al::CameraPoser* cameraPoser); +void initSnapShotCameraCtrlZoomAutoReset(al::CameraPoser* cameraPoser); +void initSnapShotCameraCtrlZoomRollMove(al::CameraPoser* cameraPoser); +void validateSnapShotCameraLookAtOffset(al::CameraPoser* cameraPoser); +void validateSnapShotCameraZoomFovy(al::CameraPoser* cameraPoser); +void validateSnapShotCameraRoll(al::CameraPoser* cameraPoser); +void updateSnapShotCameraCtrl(al::CameraPoser* cameraPoser); +void startResetSnapShotCameraCtrl(al::CameraPoser* cameraPoser, s32); +void setSnapShotMaxZoomOutFovyDegree(al::CameraPoser* cameraPoser, f32); +void getSnapShotRollDegree(const al::CameraPoser* cameraPoser); +void getSnapShotLookAtOffset(const al::CameraPoser* cameraPoser); +bool isOffVerticalAbsorb(const al::CameraPoser* cameraPoser); +void onVerticalAbsorb(al::CameraPoser* cameraPoser); +void offVerticalAbsorb(al::CameraPoser* cameraPoser); +void invalidateCameraBlur(al::CameraPoser* cameraPoser); bool isRequestStopVerticalAbsorb(const al::CameraObjectRequestInfo&); bool isRequestResetPosition(const al::CameraObjectRequestInfo&); bool isRequestResetAngleV(const al::CameraObjectRequestInfo&); @@ -185,19 +188,19 @@ void getRequestAngleSpeed(const al::CameraObjectRequestInfo&); bool isRequestMoveDownAngleV(const al::CameraObjectRequestInfo&); bool isRequestSetAngleV(const al::CameraObjectRequestInfo&); void getRequestAngleV(const al::CameraObjectRequestInfo&); -bool isInvalidCollider(const al::CameraPoser*); -void validateCollider(al::CameraPoser*); -void invalidateCollider(al::CameraPoser*); -void validateCtrlSubjective(al::CameraPoser*); -void invalidateChangeSubjective(al::CameraPoser*); -void invalidateKeepDistanceNextCamera(al::CameraPoser*); -void invalidateKeepDistanceNextCameraIfNoCollide(al::CameraPoser*); -void invalidatePreCameraEndAfterInterpole(al::CameraPoser*); -bool isInvalidPreCameraEndAfterInterpole(const al::CameraPoser*); -bool isSceneCameraFirstCalc(const al::CameraPoser*); -bool isActiveInterpole(const al::CameraPoser*); -bool isInvalidEndEntranceCamera(const al::CameraPoser*); -bool isPause(const al::CameraPoser*); +bool isInvalidCollider(const al::CameraPoser* cameraPoser); +void validateCollider(al::CameraPoser* cameraPoser); +void invalidateCollider(al::CameraPoser* cameraPoser); +void validateCtrlSubjective(al::CameraPoser* cameraPoser); +void invalidateChangeSubjective(al::CameraPoser* cameraPoser); +void invalidateKeepDistanceNextCamera(al::CameraPoser* cameraPoser); +void invalidateKeepDistanceNextCameraIfNoCollide(al::CameraPoser* cameraPoser); +void invalidatePreCameraEndAfterInterpole(al::CameraPoser* cameraPoser); +bool isInvalidPreCameraEndAfterInterpole(const al::CameraPoser* cameraPoser); +bool isSceneCameraFirstCalc(const al::CameraPoser* cameraPoser); +bool isActiveInterpole(const al::CameraPoser* cameraPoser); +bool isInvalidEndEntranceCamera(const al::CameraPoser* cameraPoser); +bool isPause(const al::CameraPoser* cameraPoser); bool checkFirstCameraCollisionArrow(sead::Vector3f*, sead::Vector3f*, const al::IUseCollision*, const sead::Vector3f&, const sead::Vector3f&); bool checkFirstCameraCollisionArrow(CameraCollisionHitResult*, const al::IUseCollision*, @@ -207,39 +210,39 @@ bool checkFirstCameraCollisionArrowOnlyCeiling(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&); void checkCameraCollisionMoveSphere(sead::Vector3f*, const al::IUseCollision*, const sead::Vector3f&, const sead::Vector3f&, f32); -f32 calcZoneRotateAngleH(f32, const al::CameraPoser*); +f32 calcZoneRotateAngleH(f32, const al::CameraPoser* cameraPoser); f32 calcZoneRotateAngleH(f32, const sead::Matrix34f&); f32 calcZoneInvRotateAngleH(f32, const sead::Matrix34f&); -void multVecZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser*); -void multVecInvZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser*); -void rotateVecZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser*); +void multVecZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser* cameraPoser); +void multVecInvZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser* cameraPoser); +void rotateVecZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser* cameraPoser); void calcOffsetCameraKeepInFrameV(sead::Vector3f*, sead::LookAtCamera*, const sead::Vector3f&, - const al::CameraPoser*, f32, f32); -void makeCameraKeepInFrameV(sead::LookAtCamera*, const sead::Vector3f&, const al::CameraPoser*, f32, - f32); -void initCameraRail(al::CameraPoser*, const al::PlacementInfo&, const char*); + const al::CameraPoser* cameraPoser, f32, f32); +void makeCameraKeepInFrameV(sead::LookAtCamera*, const sead::Vector3f&, + const al::CameraPoser* cameraPoser, f32, f32); +void initCameraRail(al::CameraPoser* cameraPoser, const al::PlacementInfo&, const char*); bool tryGetCameraRailArg(f32*, const al::PlacementInfo&, const char*, const char*); // void getCameraRailPointObjId(al::CameraPoser const*, s32); -bool tryFindNearestLimitRailKeeper(const al::CameraPoser*, const sead::Vector3f&); -void calcCameraRotateStick(sead::Vector2f*, const al::CameraPoser*); -f32 calcCameraRotateStickH(const al::CameraPoser*); -f32 calcCameraRotateStickV(const al::CameraPoser*); -f32 calcCameraRotateStickPower(const al::CameraPoser*); -s32 getStickSensitivityLevel(const al::CameraPoser*); -f32 getStickSensitivityScale(const al::CameraPoser*); -bool isValidGyro(const al::CameraPoser*); -s32 getGyroSensitivityLevel(const al::CameraPoser*); -f32 getGyroSensitivityScale(const al::CameraPoser*); -bool isTriggerCameraResetRotate(const al::CameraPoser*); -bool isHoldCameraZoom(const al::CameraPoser*); -bool isHoldCameraSnapShotZoomIn(const al::CameraPoser*); -bool isHoldCameraSnapShotZoomOut(const al::CameraPoser*); -bool isHoldCameraSnapShotRollLeft(const al::CameraPoser*); -bool isHoldCameraSnapShotRollRight(const al::CameraPoser*); -bool tryCalcCameraSnapShotMoveStick(sead::Vector2f*, const al::CameraPoser*); -bool isPlayerTypeFlyer(const al::CameraPoser*); -bool isPlayerTypeHighSpeedMove(const al::CameraPoser*); -bool isPlayerTypeHighJump(const al::CameraPoser*); -bool isPlayerTypeNotTouchGround(const al::CameraPoser*); -bool isOnRideObj(const al::CameraPoser*); +bool tryFindNearestLimitRailKeeper(const al::CameraPoser* cameraPoser, const sead::Vector3f&); +void calcCameraRotateStick(sead::Vector2f*, const al::CameraPoser* cameraPoser); +f32 calcCameraRotateStickH(const al::CameraPoser* cameraPoser); +f32 calcCameraRotateStickV(const al::CameraPoser* cameraPoser); +f32 calcCameraRotateStickPower(const al::CameraPoser* cameraPoser); +s32 getStickSensitivityLevel(const al::CameraPoser* cameraPoser); +f32 getStickSensitivityScale(const al::CameraPoser* cameraPoser); +bool isValidGyro(const al::CameraPoser* cameraPoser); +s32 getGyroSensitivityLevel(const al::CameraPoser* cameraPoser); +f32 getGyroSensitivityScale(const al::CameraPoser* cameraPoser); +bool isTriggerCameraResetRotate(const al::CameraPoser* cameraPoser); +bool isHoldCameraZoom(const al::CameraPoser* cameraPoser); +bool isHoldCameraSnapShotZoomIn(const al::CameraPoser* cameraPoser); +bool isHoldCameraSnapShotZoomOut(const al::CameraPoser* cameraPoser); +bool isHoldCameraSnapShotRollLeft(const al::CameraPoser* cameraPoser); +bool isHoldCameraSnapShotRollRight(const al::CameraPoser* cameraPoser); +bool tryCalcCameraSnapShotMoveStick(sead::Vector2f*, const al::CameraPoser* cameraPoser); +bool isPlayerTypeFlyer(const al::CameraPoser* cameraPoser); +bool isPlayerTypeHighSpeedMove(const al::CameraPoser* cameraPoser); +bool isPlayerTypeHighJump(const al::CameraPoser* cameraPoser); +bool isPlayerTypeNotTouchGround(const al::CameraPoser* cameraPoser); +bool isOnRideObj(const al::CameraPoser* cameraPoser); } // namespace alCameraPoserFunction diff --git a/lib/al/Library/Camera/CameraRequestParamHolder.h b/lib/al/Library/Camera/CameraRequestParamHolder.h index 55846174c5..1dc752e595 100644 --- a/lib/al/Library/Camera/CameraRequestParamHolder.h +++ b/lib/al/Library/Camera/CameraRequestParamHolder.h @@ -35,6 +35,10 @@ class CameraRequestParamHolder { void setGyroSensitivityLevel(s32 level) { mGyroSensitivityLevel = level; } + f32* get_60() const { return _60; } + + f32* get_58() const { return _58; } + private: s32 mStickSensitivityLevel = 0; s32 mGyroSensitivityLevel = 0; @@ -53,8 +57,8 @@ class CameraRequestParamHolder { bool mIsCurrRideObj = false; bool mIsPrevRideObj = false; const IUseCamera* mRideObjCamera = nullptr; - void* _58 = nullptr; - void* _60 = nullptr; + f32* _58 = nullptr; + f32* _60 = nullptr; }; } // namespace al diff --git a/lib/al/Library/Camera/CameraSubTargetBase.h b/lib/al/Library/Camera/CameraSubTargetBase.h index 005f7943d2..5e7ca3b236 100644 --- a/lib/al/Library/Camera/CameraSubTargetBase.h +++ b/lib/al/Library/Camera/CameraSubTargetBase.h @@ -14,6 +14,8 @@ class CameraSubTargetBase : public CameraTargetBase { void calcFront(sead::Vector3f* front) const override; void calcVelocity(sead::Vector3f* velocity) const override; + CameraSubTargetTurnParam* getSubTargetTurnParam() const { return mTurnParam; } + private: CameraSubTargetTurnParam* mTurnParam; }; diff --git a/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h b/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h new file mode 100644 index 0000000000..6b30850e90 --- /dev/null +++ b/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h @@ -0,0 +1,45 @@ +#pragma once + +#include + +#include "Library/Collision/IUseCollision.h" +#include "Library/HostIO/HioNode.h" + +namespace al { +class CollisionDirector; + +class CameraTargetCollideInfoHolder : public IUseCollision, public IUseHioNode { +public: + CameraTargetCollideInfoHolder(); + void update(bool, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&); + void reset(); + bool isExistUnderWall() const; + bool tryCalcSlopDownFrontDirH(sead::Vector3f*) const; + CollisionDirector* getCollisionDirector() const override; + + bool isExistCollisionUnderTarget() const { return mIsExistCollisionUnderTarget; } + + const sead::Vector3f& getTargetCollisionPos() const { return mTargetCollisionPos; } + + const sead::Vector3f& getTargetCollisionNormal() const { return mTargetCollisionNormal; } + + bool isExistSlopeCollisionUnderTarget() const { return mIsExistSlopeCollisionUnderTarget; } + + f32 getSlopeCollisionUpSpeed() const { return mSlopeCollisionUpSpeed; } + + f32 getSlopeCollisionDownSpeed() const { return mSlopeCollisionDownSpeed; } + +private: + void* mBuffer; + char mBuffer2; + bool mIsExistCollisionUnderTarget; + void* mBuffer3; + sead::Vector3f mTargetCollisionNormal; + sead::Vector3f mTargetCollisionPos; + bool mIsExistSlopeCollisionUnderTarget; + char mBuffer4[0xc]; + f32 mSlopeCollisionDownSpeed; + f32 mSlopeCollisionUpSpeed; +}; + +} // namespace al diff --git a/lib/al/Library/Camera/CameraTargetHolder.h b/lib/al/Library/Camera/CameraTargetHolder.h index 13f055925d..52cf1da043 100644 --- a/lib/al/Library/Camera/CameraTargetHolder.h +++ b/lib/al/Library/Camera/CameraTargetHolder.h @@ -34,13 +34,19 @@ class CameraTargetHolder { void addPlacementSubTarget(CameraSubTargetBase* subTarget); void removePlacementSubTarget(CameraSubTargetBase* subTarget); + bool isChangeViewTarget(u32 index) const; + + s8 hasTopSubTargetChanged() const { return mHasTopSubTargetChanged; } + + CameraSubTargetBase* getTopSubTargetInline() const { return mTopSubTarget; } + private: s32 mViewTargetSize = 0; CameraTargetBase** mViewTargetArray = nullptr; ViewTargetInfo* mViewTargetInfo = nullptr; sead::PtrArray mTargetArray; CameraSubTargetBase* mTopSubTarget = nullptr; - bool mHasTopSubTargetChanged = false; + s8 mHasTopSubTargetChanged = false; // What? This is required to match? sead::PtrArray mSubTargetArray; sead::PtrArray mPlacementSubTargetArray; }; diff --git a/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h b/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h index 4fd012f06f..95b5233e38 100644 --- a/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h +++ b/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h @@ -30,6 +30,22 @@ class CameraVerticalAbsorber : public NerveExecutor { void exeFollowClimbPole(); void exeFollowAbsolute(); + f32 getAbsorbScreenPosUp() const { return mAbsorbScreenPosUp; } + + f32 getAbsorbScreenPosDown() const { return mAbsorbScreenPosDown; } + + void setIsStopUpdate(bool isStopUpdate) { mIsStopUpdate = isStopUpdate; } + + void setIsKeepInFrame(bool isKeepInFrame) { mIsKeepInFrame = isKeepInFrame; } + + void setKeepInFrameOffsetUp(f32 keepInFrameOffsetUp) { + mKeepInFrameOffsetUp = keepInFrameOffsetUp; + } + + void setKeepInFrameOffsetDown(f32 keepInFrameOffsetDown) { + mKeepInFrameOffsetDown = keepInFrameOffsetDown; + } + private: const CameraPoser* mCameraPoser; sead::LookAtCamera mLookAtCamera; diff --git a/lib/al/Project/Camera/CameraSubTargetTurnParam.h b/lib/al/Project/Camera/CameraSubTargetTurnParam.h index b431b6f054..df2699d010 100644 --- a/lib/al/Project/Camera/CameraSubTargetTurnParam.h +++ b/lib/al/Project/Camera/CameraSubTargetTurnParam.h @@ -11,6 +11,32 @@ class CameraSubTargetTurnParam { void init(const ActorInitInfo& info); + f32 getValidTurnDegreeRangeH() const { return mValidTurnDegreeRangeH; } + + f32 getValidFaceDegreeRangeH() const { return mValidFaceDegreeRangeH; } + + f32 getTurnSpeedRate1() const { return mTurnSpeedRate1; } + + f32 getTurnSpeedRate2() const { return mTurnSpeedRate2; } + + s32 getTargetTurnRestartStep() const { return mTargetTurnRestartStep; } + + f32 getTurnStopStartDistance() const { return mTurnStopStartDistance; } + + f32 getTurnBrakeEndDistance() const { return mTurnBrakeEndDistance; } + + f32 getTurnBrakeStartDistance() const { return mTurnBrakeStartDistance; } + + f32 getTurnStopEndDistance() const { return mTurnStopEndDistance; } + + bool isTurnV() const { return mIsTurnV; } + + bool isResetAfterTurnV() const { return mIsResetAfterTurnV; } + + f32 getMinTurnDegreeV() const { return mMinTurnDegreeV; } + + f32 getMaxTurnDegreeV() const { return mMaxTurnDegreeV; } + private: f32 mTurnSpeedRate1 = 0.3f; f32 mTurnSpeedRate2 = 0.1f; @@ -18,7 +44,7 @@ class CameraSubTargetTurnParam { f32 mTurnBrakeStartDistance = -1.0f; f32 mTurnStopStartDistance = -1.0f; f32 mTurnStopEndDistance = -1.0f; - s32 _18 = 30; + s32 mTargetTurnRestartStep = 30; bool mIsTurnV = false; bool mIsResetAfterTurnV = false; f32 mMinTurnDegreeV = 0.0f; diff --git a/src/Player/PlayerJudgeSleep.h b/src/Player/PlayerJudgeSleep.h index 13e053fa88..20a399737c 100644 --- a/src/Player/PlayerJudgeSleep.h +++ b/src/Player/PlayerJudgeSleep.h @@ -7,8 +7,8 @@ class PlayerStateWait; class PlayerJudgeSleep : public IJudge { public: PlayerJudgeSleep(const PlayerStateWait* stateWait); - void reset() override {}; - void update() override {}; + void reset() override{}; + void update() override{}; bool judge() const override; private: From a7c0707ca90bcf19f54671996e4830591744d7e0 Mon Sep 17 00:00:00 2001 From: Narr the Reg <5944268+german77@users.noreply.github.com> Date: Sun, 5 Jul 2026 12:55:31 -0600 Subject: [PATCH 2/7] first cleanup pass --- lib/al/Library/Camera/CameraPoserFunction.cpp | 463 ++++++++---------- lib/al/Library/Camera/CameraPoserFunction.h | 4 +- lib/al/Library/Camera/CameraSubTargetBase.h | 2 +- .../Camera/CameraSubTargetTurnParam.cpp | 24 +- .../Project/Camera/CameraSubTargetTurnParam.h | 58 +-- 5 files changed, 231 insertions(+), 320 deletions(-) diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp index f65d9e9446..ebe83ca469 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.cpp +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -24,6 +24,10 @@ s32 getViewIndex(const al::CameraPoser* cameraPoser) { return cameraPoser->getCameraViewInfo()->getIndex(); } +static s32 getViewInfoIndex(const al::CameraPoser* cameraPoser) { + return cameraPoser->getViewInfo()->getIndex(); +} + const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser) { return cameraPoser->getCameraViewInfo()->getLookAtCam(); } @@ -49,23 +53,23 @@ f32 getAspect(const al::CameraPoser* cameraPoser) { } const sead::Vector3f& getPreCameraPos(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getLookAtCam().getPos(); + return getLookAtCamera(cameraPoser).getPos(); } const sead::Vector3f& getPreLookAtPos(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getLookAtCam().getAt(); + return getLookAtCamera(cameraPoser).getAt(); } const sead::Vector3f& getPreUpDir(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getLookAtCam().getUp(); + return getLookAtCamera(cameraPoser).getUp(); } f32 getPreFovyDegree(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getProjection().getFovy() * 57.29578f; + return sead::Mathf::rad2deg(getPreFovyRadian(cameraPoser)); } f32 getPreFovyRadian(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getProjection().getFovy(); + return getProjection(cameraPoser).getFovy(); } bool isPrePriorityDemo(const al::CameraStartInfo& cameraStartInfo) { @@ -81,8 +85,7 @@ bool isPrePriorityDemoTalk(const al::CameraStartInfo& cameraStartInfo) { } bool isPrePriorityDemoAll(const al::CameraStartInfo& cameraStartInfo) { - return cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Demo || - cameraStartInfo.prePriorityType == al::CameraTicket::Priority_Demo2; + return isPrePriorityDemo(cameraStartInfo) || isPrePriorityDemo2(cameraStartInfo); } bool isPrePriorityEntranceAll(const al::CameraStartInfo& cameraStartInfo) { @@ -101,10 +104,7 @@ bool isEqualPreCameraName(const al::CameraStartInfo& cameraStartInfo, const char } bool isPreCameraFixAbsolute(const al::CameraStartInfo& cameraStartInfo) { - const char* cameraName = al::CameraPoserFix::getFixAbsoluteCameraName(); - if (cameraStartInfo.preCameraName) - return al::isEqualString(cameraName, cameraStartInfo.preCameraName); - return false; + return isEqualPreCameraName(cameraStartInfo, al::CameraPoserFix::getFixAbsoluteCameraName()); } bool isInvalidCollidePreCamera(const al::CameraStartInfo& cameraStartInfo) { @@ -172,131 +172,108 @@ f32 getNextAngleVByPreCamera(const al::CameraStartInfo& cameraStartInfo) { } void calcCameraPose(sead::Quatf* out, const al::CameraPoser* cameraPoser) { - sead::Vector3f vec; - vec.x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; - vec.y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; - vec.z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; - - al::normalize(&vec); - vec.negate(); - al::makeQuatFrontUp(out, vec, cameraPoser->getCameraUp()); + sead::Vector3f lookDir; + calcLookDir(&lookDir, cameraPoser); + al::makeQuatFrontUp(out, lookDir, cameraPoser->getUp()); } void calcLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; - out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; - out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; - al::normalize(out); + calcCameraDir(out, cameraPoser); out->negate(); } void calcCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; - out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; - out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; + out->setSub(cameraPoser->getEye(), cameraPoser->getAt()); al::normalize(out); } -void calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; - out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; - out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; - al::verticalizeVec(out, cameraPoser->getCameraUp(), *out); - al::tryNormalizeOrZero(out); +bool calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { + out->setSub(cameraPoser->getEye(), cameraPoser->getAt()); + al::verticalizeVec(out, cameraPoser->getUp(), *out); + return al::tryNormalizeOrZero(out); } bool calcLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - out->x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; - out->y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; - out->z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; - al::verticalizeVec(out, cameraPoser->getCameraUp(), *out); - bool ret = al::tryNormalizeOrZero(out); + bool isValid = calcCameraDirH(out, cameraPoser); out->negate(); - return ret; + return isValid; } void calcSideDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = cameraPoser->getPosition() - cameraPoser->getTargetTrans(); + sead::Vector3f vec = cameraPoser->getEye() - cameraPoser->getAt(); al::normalize(&vec); - *out = vec.cross(cameraPoser->getCameraUp()); + out->set(vec.cross(cameraPoser->getUp())); al::normalize(out); } void calcPreCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); - out->x = lookAtCam.getPos().x - lookAtCam.getAt().x; - out->y = lookAtCam.getPos().y - lookAtCam.getAt().y; - out->z = lookAtCam.getPos().z - lookAtCam.getAt().z; + const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser); + out->setSub(lookAtCam.getPos(), lookAtCam.getAt()); al::normalize(out); } void calcPreCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); - out->x = lookAtCam.getPos().x - lookAtCam.getAt().x; - out->y = lookAtCam.getPos().y - lookAtCam.getAt().y; - out->z = lookAtCam.getPos().z - lookAtCam.getAt().z; + const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser); + out->setSub(lookAtCam.getPos(), lookAtCam.getAt()); al::verticalizeVec(out, sead::Vector3f::ey, *out); al::tryNormalizeOrZero(out); } void calcPreLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); - out->x = lookAtCam.getPos().x - lookAtCam.getAt().x; - out->y = lookAtCam.getPos().y - lookAtCam.getAt().y; - out->z = lookAtCam.getPos().z - lookAtCam.getAt().z; - al::normalize(out); + calcPreCameraDir(out, cameraPoser); out->negate(); } void calcPreLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - const sead::LookAtCamera& lookAtCam = cameraPoser->getCameraViewInfo()->getLookAtCam(); + const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser); out->set(lookAtCam.getAt() - lookAtCam.getPos()); - al::verticalizeVec(out, cameraPoser->getCameraViewInfo()->getLookAtCam().getUp(), *out); + al::verticalizeVec(out, getPreUpDir(cameraPoser), *out); al::tryNormalizeOrZero(out); } f32 calcPreCameraAngleH(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; + sead::Vector3f vec = {0.0f, 0.0f, 0.0f}; calcPreCameraDirH(&vec, cameraPoser); - return sead::Mathf::atan2(vec.x, vec.z) * 57.29578f; + return sead::Mathf::rad2deg(sead::Mathf::atan2(vec.x, vec.z)); } f32 calcPreCameraAngleV(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - calcPreCameraDir(&vec, cameraPoser); - al::parallelizeVec(&vec, sead::Vector3f::ey, vec); - return sead::Mathf::asin(sead::Mathf::sqrt(vec.dot(vec))) * 57.29578f; + sead::Vector3f cameraDir = {0.0f, 0.0f, 0.0f}; + calcPreCameraDir(&cameraDir, cameraPoser); + al::parallelizeVec(&cameraDir, sead::Vector3f::ey, cameraDir); + return sead::Mathf::rad2deg(sead::Mathf::asin(cameraDir.length())); } void setLookAtPosToTarget(al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - calcTargetTrans(&vec, cameraPoser); - cameraPoser->setTargetTrans(vec); + sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f}; + calcTargetTrans(&targetTrans, cameraPoser); + cameraPoser->setAt(targetTrans); +} + +static inline al::CameraTargetBase* getTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getTargetHolder()->getViewTarget(getViewInfoIndex(cameraPoser)); } void calcTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - cameraTargetBase->calcTrans(out); + getTarget(cameraPoser)->calcTrans(out); } void setLookAtPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset) { - sead::Vector3f vec = {0, 0, 0}; - calcTargetTrans(&vec, cameraPoser); - cameraPoser->setTargetTrans(vec + offset); + sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f}; + calcTargetTrans(&targetTrans, cameraPoser); + cameraPoser->setAt(targetTrans + offset); } void setCameraPosToTarget(al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - calcTargetTrans(&vec, cameraPoser); - cameraPoser->setPosition(vec); + sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f}; + calcTargetTrans(&targetTrans, cameraPoser); + cameraPoser->setEye(targetTrans); } void setCameraPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset) { - sead::Vector3f vec = {0, 0, 0}; - calcTargetTrans(&vec, cameraPoser); - cameraPoser->setPosition(vec + offset); + sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f}; + calcTargetTrans(&targetTrans, cameraPoser); + cameraPoser->setEye(targetTrans + offset); } void calcTargetTransWithOffset(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { @@ -307,10 +284,7 @@ void calcTargetTransWithOffset(sead::Vector3f* out, const al::CameraPoser* camer } void calcTargetVelocity(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - cameraTargetBase->calcVelocity(out); + getTarget(cameraPoser)->calcVelocity(out); } void calcTargetVelocityH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { @@ -321,100 +295,93 @@ void calcTargetVelocityH(sead::Vector3f* out, const al::CameraPoser* cameraPoser } void calcTargetUp(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - cameraTargetBase->calcUp(out); + getTarget(cameraPoser)->calcUp(out); } f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - sead::Vector3f vec2 = {0, 0, 0}; - calcTargetVelocity(&vec, cameraPoser); - calcTargetUp(&vec2, cameraPoser); - al::parallelizeVec(&vec, vec2, vec); + sead::Vector3f targetVelocity = {0.0f, 0.0f, 0.0f}; + sead::Vector3f targetUp = {0.0f, 0.0f, 0.0f}; + calcTargetVelocity(&targetVelocity, cameraPoser); + calcTargetUp(&targetUp, cameraPoser); + al::parallelizeVec(&targetVelocity, targetUp, targetVelocity); + + f32 direction = targetVelocity.dot(targetUp); + f32 speedV = targetVelocity.length(); - f32 dot = vec.dot(vec2); - f32 sqrtDot = sead::Mathf::sqrt(vec.dot(vec)); - if (!(dot > 0.0f)) - sqrtDot = -sqrtDot; - return sqrtDot; + if (direction > 0.0f) + return speedV; + else + return -speedV; } void calcTargetPose(sead::Quatf* out, const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - sead::Vector3f vec2 = {0, 0, 0}; - calcTargetUp(&vec, cameraPoser); - calcTargetFront(&vec2, cameraPoser); - al::makeQuatFrontUp(out, vec2, vec); + sead::Vector3f targetUp = {0.0f, 0.0f, 0.0f}; + sead::Vector3f targetFront = {0.0f, 0.0f, 0.0f}; + calcTargetUp(&targetUp, cameraPoser); + calcTargetFront(&targetFront, cameraPoser); + al::makeQuatFrontUp(out, targetFront, targetUp); } void calcTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - cameraTargetBase->calcFront(out); + getTarget(cameraPoser)->calcFront(out); } void calcTargetSide(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - cameraTargetBase->calcSide(out); + getTarget(cameraPoser)->calcSide(out); } void calcTargetGravity(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - cameraTargetBase->calcGravity(out); + getTarget(cameraPoser)->calcGravity(out); } f32 calcTargetSpeedH(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - sead::Vector3f vec2 = {0, 0, 0}; - calcTargetGravity(&vec, cameraPoser); - calcTargetVelocity(&vec2, cameraPoser); - al::verticalizeVec(&vec2, vec, vec2); - return sead::Mathf::sqrt(vec2.dot(vec2)); + sead::Vector3f targetGravity = {0.0f, 0.0f, 0.0f}; + sead::Vector3f targetVelocity = {0.0f, 0.0f, 0.0f}; + calcTargetGravity(&targetGravity, cameraPoser); + calcTargetVelocity(&targetVelocity, cameraPoser); + + al::verticalizeVec(&targetVelocity, targetGravity, targetVelocity); + return targetVelocity.length(); } f32 calcTargetJumpSpeed(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - sead::Vector3f vec2 = {0, 0, 0}; - calcTargetGravity(&vec, cameraPoser); - calcTargetVelocity(&vec2, cameraPoser); - al::parallelizeVec(&vec2, vec, vec2); - if (!al::isNearZero(vec2, 0.001f) && !(vec.dot(vec2) > 0.0f)) - return sead::Mathf::sqrt(vec2.dot(vec2)); - return 0.0f; + sead::Vector3f targetGravity = {0.0f, 0.0f, 0.0f}; + sead::Vector3f targetVelocity = {0.0f, 0.0f, 0.0f}; + calcTargetGravity(&targetGravity, cameraPoser); + calcTargetVelocity(&targetVelocity, cameraPoser); + + al::parallelizeVec(&targetVelocity, targetGravity, targetVelocity); + if (al::isNearZero(targetVelocity) || targetGravity.dot(targetVelocity) > 0.0f) + return 0.0f; + + return targetVelocity.length(); } f32 calcTargetFallSpeed(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0, 0, 0}; - sead::Vector3f vec2 = {0, 0, 0}; - calcTargetGravity(&vec, cameraPoser); - calcTargetVelocity(&vec2, cameraPoser); - al::parallelizeVec(&vec2, vec, vec2); - if (!al::isNearZero(vec2, 0.001f) && !(vec.dot(vec2) < 0.0f)) - return sead::Mathf::sqrt(vec2.dot(vec2)); - return 0.0f; + sead::Vector3f targetGravity = {0.0f, 0.0f, 0.0f}; + sead::Vector3f targetVelocity = {0.0f, 0.0f, 0.0f}; + calcTargetGravity(&targetGravity, cameraPoser); + calcTargetVelocity(&targetVelocity, cameraPoser); + + al::parallelizeVec(&targetVelocity, targetGravity, targetVelocity); + if (al::isNearZero(targetVelocity) || targetGravity.dot(targetVelocity) < 0.0f) + return 0.0f; + + return targetVelocity.length(); } bool isChangeTarget(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - return cameraTargetHolder->isChangeViewTarget(cameraPoser->getViewInfo()->getIndex()); + return cameraPoser->getTargetHolder()->isChangeViewTarget(getViewInfoIndex(cameraPoser)); } bool tryGetTargetRequestDistance(f32* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraTargetBase* cameraTargetBase = - cameraTargetHolder->getViewTarget(cameraPoser->getViewInfo()->getIndex()); - f32 requestDistance = cameraTargetBase->getRequestDistance(); - if (requestDistance > 0.0) { - *out = cameraTargetBase->getRequestDistance(); + al::CameraTargetBase* target = getTarget(cameraPoser); + + if (target->getRequestDistance() > 0.0f) { + *out = target->getRequestDistance(); return true; } + return false; } @@ -426,92 +393,90 @@ f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) { return cameraPoser->getCameraPoserSceneInfo()->requestParamHolder->get_58(); } +static inline al::CameraTargetCollideInfoHolder* +getTargetCollision(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; +} + bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo() - ->targetCollideInfoHolder->isExistCollisionUnderTarget(); + return getTargetCollision(cameraPoser)->isExistCollisionUnderTarget(); } const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder->getTargetCollisionPos(); + return getTargetCollision(cameraPoser)->getTargetCollisionPos(); } const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo() - ->targetCollideInfoHolder->getTargetCollisionNormal(); + return getTargetCollision(cameraPoser)->getTargetCollisionNormal(); } bool isExistSlopeCollisionUnderTarget(const al::CameraPoser* cameraPoser) { - al::CameraTargetCollideInfoHolder* cameraTargetCollideInfoHolder = - cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; - if (cameraTargetCollideInfoHolder->isExistCollisionUnderTarget()) - return cameraTargetCollideInfoHolder->isExistSlopeCollisionUnderTarget(); - return false; + return isExistCollisionUnderTarget(cameraPoser) && + getTargetCollision(cameraPoser)->isExistSlopeCollisionUnderTarget(); } bool isExistWallCollisionUnderTarget(const al::CameraPoser* cameraPoser) { - al::CameraTargetCollideInfoHolder* cameraTargetCollideInfoHolder = - cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; - return cameraTargetCollideInfoHolder->isExistUnderWall(); + return getTargetCollision(cameraPoser)->isExistUnderWall(); } bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetCollideInfoHolder* cameraTargetCollideInfoHolder = - cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; - return cameraTargetCollideInfoHolder->tryCalcSlopDownFrontDirH(out); + return getTargetCollision(cameraPoser)->tryCalcSlopDownFrontDirH(out); } f32 getSlopeCollisionUpSpeed(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo() - ->targetCollideInfoHolder->getSlopeCollisionUpSpeed(); + return getTargetCollision(cameraPoser)->getSlopeCollisionUpSpeed(); } f32 getSlopeCollisionDownSpeed(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo() - ->targetCollideInfoHolder->getSlopeCollisionDownSpeed(); + return getTargetCollision(cameraPoser)->getSlopeCollisionDownSpeed(); } bool isExistSubTarget(const al::CameraPoser* cameraPoser) { return cameraPoser->getTargetHolder()->getTopSubTargetInline(); } +static inline al::CameraSubTargetBase* getTopSubTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getTargetHolder()->getTopSubTarget(); +} + +static inline al::CameraSubTargetTurnParam* +getSubTargetTurnParam(const al::CameraPoser* cameraPoser) { + return getTopSubTarget(cameraPoser)->getSubTargetTurnParam(); +} + bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser) { - if (!cameraPoser->getTargetHolder()->getTopSubTargetInline()) + if (!isExistSubTarget(cameraPoser)) return false; - al::CameraTargetHolder* cameraTargetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* topSubTarget = cameraTargetHolder->getTopSubTarget(); - al::CameraSubTargetTurnParam* subTargetTurnParam = topSubTarget->getSubTargetTurnParam(); - if (subTargetTurnParam->getValidTurnDegreeRangeH() < 0.0f && - subTargetTurnParam->getValidFaceDegreeRangeH() != 0.0f) { + + al::CameraSubTargetTurnParam* subTargetTurnParam = getSubTargetTurnParam(cameraPoser); + if (subTargetTurnParam->validTurnDegreeRangeH < 0.0f && + subTargetTurnParam->validFaceDegreeRangeH != 0.0f) { return true; } - sead::Vector3f vec = {}; - vec.x = cameraPoser->getPosition().x - cameraPoser->getTargetTrans().x; - vec.y = cameraPoser->getPosition().y - cameraPoser->getTargetTrans().y; - vec.z = cameraPoser->getPosition().z - cameraPoser->getTargetTrans().z; - al::verticalizeVec(&vec, cameraPoser->getCameraUp(), vec); - bool ret = al::tryNormalizeOrZero(&vec); - vec.negate(); - if (!ret) + + sead::Vector3f lookDirH = {}; + if (!calcLookDirH(&lookDirH, cameraPoser)) return false; - if (subTargetTurnParam->getValidFaceDegreeRangeH() >= 0.0f) { - sead::Vector3f vec2 = {0, 0, 0}; - calcSubTargetBack(&vec2, cameraPoser); - f32 validFaceDegreeRangeH = subTargetTurnParam->getValidFaceDegreeRangeH(); - f32 angleDegree = al::calcAngleDegree(vec2, vec); - if (validFaceDegreeRangeH < angleDegree) + + if (subTargetTurnParam->validFaceDegreeRangeH >= 0.0f) { + sead::Vector3f targetBack = {0.0f, 0.0f, 0.0f}; + calcSubTargetBack(&targetBack, cameraPoser); + if (subTargetTurnParam->validFaceDegreeRangeH < al::calcAngleDegree(targetBack, lookDirH)) return false; } - if (subTargetTurnParam->getValidTurnDegreeRangeH() >= 0.0f) { - sead::Vector3f vec2 = {0, 0, 0}; - sead::Vector3f vec3 = {0, 0, 0}; - calcSubTargetTrans(&vec2, cameraPoser); - vec3 = vec2 - cameraPoser->getPosition(); - al::verticalizeVec(&vec3, cameraPoser->getCameraUp(), vec3); - if (!al::tryNormalizeOrZero(&vec3)) + + if (subTargetTurnParam->validTurnDegreeRangeH >= 0.0f) { + sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f}; + sead::Vector3f lookDir = {0.0f, 0.0f, 0.0f}; + calcSubTargetTrans(&targetTrans, cameraPoser); + lookDir = targetTrans - cameraPoser->getEye(); + al::verticalizeVec(&lookDir, cameraPoser->getUp(), lookDir); + if (!al::tryNormalizeOrZero(&lookDir)) return false; - if (subTargetTurnParam->getValidTurnDegreeRangeH() / 2 < al::calcAngleDegree(vec, vec3)) + if (subTargetTurnParam->validTurnDegreeRangeH / 2 < al::calcAngleDegree(lookDirH, lookDir)) return false; } + return true; } @@ -521,161 +486,133 @@ void calcSubTargetBack(sead::Vector3f* out, const al::CameraPoser* cameraPoser) } void calcSubTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - subTargetBase->calcTrans(out); + getTopSubTarget(cameraPoser)->calcTrans(out); } bool isChangeSubTarget(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - return targetHolder->hasTopSubTargetChanged(); + return cameraPoser->getTargetHolder()->hasTopSubTargetChanged(); } void calcSubTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - subTargetBase->calcFront(out); + getTopSubTarget(cameraPoser)->calcFront(out); } f32 getSubTargetRequestDistance(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - return subTargetBase->getRequestDistance(); + return getTopSubTarget(cameraPoser)->getRequestDistance(); } f32 getSubTargetTurnSpeedRate1(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - return subTargetBase->getSubTargetTurnParam()->getTurnSpeedRate1(); + return getSubTargetTurnParam(cameraPoser)->turnSpeedRate1; } f32 getSubTargetTurnSpeedRate2(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - return subTargetBase->getSubTargetTurnParam()->getTurnSpeedRate2(); + return getSubTargetTurnParam(cameraPoser)->turnSpeedRate2; } s32 getSubTargetTurnRestartStep(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - return subTargetBase->getSubTargetTurnParam()->getTargetTurnRestartStep(); + return getSubTargetTurnParam(cameraPoser)->targetTurnRestartStep; } bool tryCalcSubTargetTurnBrakeDistanceRate(f32* out, const al::CameraPoser* cameraPoser) { - al::CameraSubTargetBase* subTargetBase = cameraPoser->getTargetHolder()->getTopSubTarget(); - al::CameraSubTargetTurnParam* turnParam = subTargetBase->getSubTargetTurnParam(); + al::CameraSubTargetTurnParam* turnParam = getSubTargetTurnParam(cameraPoser); - sead::Vector3f vec = {0, 0, 0}; - sead::Vector3f vec2 = {0, 0, 0}; + sead::Vector3f vec = {0.0f, 0.0f, 0.0f}; + sead::Vector3f vec2 = {0.0f, 0.0f, 0.0f}; calcTargetTrans(&vec, cameraPoser); calcSubTargetTrans(&vec2, cameraPoser); f32 distance = sead::Mathf::sqrt(sead::Mathf::pow(vec.x - vec2.x, 2) + sead::Mathf::pow(vec.z - vec2.z, 2)); - f32 turnBrakeDistance = turnParam->getTurnBrakeEndDistance(); - if (turnBrakeDistance > 0.0f) { - f32 turnBrakeStartDistance = turnParam->getTurnBrakeStartDistance(); - if (turnBrakeDistance < turnBrakeStartDistance && distance < turnBrakeStartDistance) { - *out = 1.0f - al::normalize(distance, turnBrakeDistance, turnBrakeStartDistance); - return true; - } + if (turnParam->turnBrakeEndDistance > 0.0f && + turnParam->turnBrakeEndDistance < turnParam->turnBrakeStartDistance && + distance < turnParam->turnBrakeStartDistance) { + *out = 1.0f - al::normalize(distance, turnParam->turnBrakeEndDistance, + turnParam->turnBrakeStartDistance); + return true; } - f32 turnStopStartDistance = turnParam->getTurnStopStartDistance(); - if (turnStopStartDistance > 0.0f) { - f32 turnStopEndDistance = turnParam->getTurnStopEndDistance(); - if (turnStopStartDistance < turnStopEndDistance && turnStopStartDistance < distance) { - *out = al::normalize(distance, turnStopStartDistance, turnStopEndDistance); - return true; - } + if (turnParam->turnStopStartDistance > 0.0f && + turnParam->turnStopStartDistance < turnParam->turnStopEndDistance && + turnParam->turnStopStartDistance < distance) { + *out = al::normalize(distance, turnParam->turnStopStartDistance, + turnParam->turnStopEndDistance); + return true; } return false; } bool isValidSubTargetTurnV(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - return subTargetBase->getSubTargetTurnParam()->isTurnV(); + return getSubTargetTurnParam(cameraPoser)->isTurnV; } bool isValidSubTargetResetAfterTurnV(const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* subTargetBase = targetHolder->getTopSubTarget(); - return subTargetBase->getSubTargetTurnParam()->isResetAfterTurnV(); + return getSubTargetTurnParam(cameraPoser)->isResetAfterTurnV; } void clampAngleSubTargetTurnRangeV(f32* out, const al::CameraPoser* cameraPoser) { - al::CameraTargetHolder* targetHolder = cameraPoser->getTargetHolder(); - al::CameraSubTargetBase* topSubTarget = targetHolder->getTopSubTarget(); - f32 minTurnDegree = topSubTarget->getSubTargetTurnParam()->getMinTurnDegreeV(); - f32 maxTurnDegree = 0.0f; - - f32 outParam = *out; - if (!(outParam < minTurnDegree)) { - maxTurnDegree = topSubTarget->getSubTargetTurnParam()->getMaxTurnDegreeV(); - minTurnDegree = outParam; - if (outParam > maxTurnDegree) - minTurnDegree = maxTurnDegree; - } - *out = minTurnDegree; + al::CameraSubTargetBase* topSubTarget = getTopSubTarget(cameraPoser); + f32 min = topSubTarget->getSubTargetTurnParam()->minTurnDegreeV; + f32 max = topSubTarget->getSubTargetTurnParam()->maxTurnDegreeV; + + *out = sead::Mathf::clamp(*out, min, max); } void initCameraVerticalAbsorber(al::CameraPoser* cameraPoser) { - al::CameraVerticalAbsorber* cameraVerticalAbsorber = - new al::CameraVerticalAbsorber(cameraPoser, false); - cameraPoser->setVerticalAbsorber(cameraVerticalAbsorber); + cameraPoser->setVerticalAbsorber(new al::CameraVerticalAbsorber(cameraPoser, false)); } void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser* cameraPoser) { - al::CameraVerticalAbsorber* cameraVerticalAbsorber = - new al::CameraVerticalAbsorber(cameraPoser, true); - cameraPoser->setVerticalAbsorber(cameraVerticalAbsorber); + cameraPoser->setVerticalAbsorber(new al::CameraVerticalAbsorber(cameraPoser, true)); +} + +static inline al::CameraVerticalAbsorber* getVerticalAbsorber(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraVerticalAbsorber(); } f32 getCameraVerticalAbsorbPosUp(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraVerticalAbsorber()->getAbsorbScreenPosUp(); + return getVerticalAbsorber(cameraPoser)->getAbsorbScreenPosUp(); } f32 getCameraVerticalAbsorbPosDown(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraVerticalAbsorber()->getAbsorbScreenPosDown(); + return getVerticalAbsorber(cameraPoser)->getAbsorbScreenPosDown(); } void liberateVerticalAbsorb(al::CameraPoser* cameraPoser) { - cameraPoser->getCameraVerticalAbsorber()->liberateAbsorb(); + getVerticalAbsorber(cameraPoser)->liberateAbsorb(); } void stopUpdateVerticalAbsorb(al::CameraPoser* cameraPoser) { - cameraPoser->getCameraVerticalAbsorber()->setIsStopUpdate(true); + getVerticalAbsorber(cameraPoser)->setIsStopUpdate(true); } void stopUpdateVerticalAbsorbForSnapShotMode(al::CameraPoser* cameraPoser, const sead::Vector3f& absorbVec) { stopUpdateVerticalAbsorb(cameraPoser); - cameraPoser->getCameraVerticalAbsorber()->tryResetAbsorbVecIfInCollision(absorbVec); + getVerticalAbsorber(cameraPoser)->tryResetAbsorbVecIfInCollision(absorbVec); } void restartUpdateVerticalAbsorb(al::CameraPoser* cameraPoser) { - cameraPoser->getCameraVerticalAbsorber()->setIsStopUpdate(false); + getVerticalAbsorber(cameraPoser)->setIsStopUpdate(false); } void validateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser) { - cameraPoser->getCameraVerticalAbsorber()->setIsKeepInFrame(true); + getVerticalAbsorber(cameraPoser)->setIsKeepInFrame(true); } void invalidateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser) { - cameraPoser->getCameraVerticalAbsorber()->setIsKeepInFrame(false); + getVerticalAbsorber(cameraPoser)->setIsKeepInFrame(false); } void setVerticalAbsorbKeepInFrameScreenOffsetUp(al::CameraPoser* cameraPoser, f32 keepInFrameOffsetUp) { - cameraPoser->getCameraVerticalAbsorber()->setKeepInFrameOffsetUp(keepInFrameOffsetUp); + getVerticalAbsorber(cameraPoser)->setKeepInFrameOffsetUp(keepInFrameOffsetUp); } void setVerticalAbsorbKeepInFrameScreenOffsetDown(al::CameraPoser* cameraPoser, f32 keepInFrameOffsetDown) { - cameraPoser->getCameraVerticalAbsorber()->setKeepInFrameOffsetDown(keepInFrameOffsetDown); + getVerticalAbsorber(cameraPoser)->setKeepInFrameOffsetDown(keepInFrameOffsetDown); } void initCameraArrowCollider(al::CameraPoser* cameraPoser) { diff --git a/lib/al/Library/Camera/CameraPoserFunction.h b/lib/al/Library/Camera/CameraPoserFunction.h index 0be549b35a..c5211ac595 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.h +++ b/lib/al/Library/Camera/CameraPoserFunction.h @@ -41,7 +41,7 @@ bool isPrePriorityDemoTalk(const al::CameraStartInfo& cameraStartInfo); bool isPrePriorityDemoAll(const al::CameraStartInfo& cameraStartInfo); bool isPrePriorityEntranceAll(const al::CameraStartInfo& cameraStartInfo); bool isPrePriorityPlayer(const al::CameraStartInfo& cameraStartInfo); -bool isEqualPreCameraName(const al::CameraStartInfo& cameraStartInfo, const char*); +bool isEqualPreCameraName(const al::CameraStartInfo& cameraStartInfo, const char* cameraName); bool isPreCameraFixAbsolute(const al::CameraStartInfo& cameraStartInfo); bool isInvalidCollidePreCamera(const al::CameraStartInfo& cameraStartInfo); bool isInvalidKeepPreCameraDistance(const al::CameraStartInfo& cameraStartInfo); @@ -62,7 +62,7 @@ f32 getNextAngleVByPreCamera(const al::CameraStartInfo& cameraStartInfo); void calcCameraPose(sead::Quatf* out, const al::CameraPoser* cameraPoser); void calcLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); void calcCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +bool calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); bool calcLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); void calcSideDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); void calcPreCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); diff --git a/lib/al/Library/Camera/CameraSubTargetBase.h b/lib/al/Library/Camera/CameraSubTargetBase.h index 5e7ca3b236..fb6706c317 100644 --- a/lib/al/Library/Camera/CameraSubTargetBase.h +++ b/lib/al/Library/Camera/CameraSubTargetBase.h @@ -3,7 +3,7 @@ #include "Library/Camera/CameraTargetBase.h" namespace al { -class CameraSubTargetTurnParam; +struct CameraSubTargetTurnParam; class CameraSubTargetBase : public CameraTargetBase { public: diff --git a/lib/al/Project/Camera/CameraSubTargetTurnParam.cpp b/lib/al/Project/Camera/CameraSubTargetTurnParam.cpp index 8b13c86d15..6df7d16c6e 100644 --- a/lib/al/Project/Camera/CameraSubTargetTurnParam.cpp +++ b/lib/al/Project/Camera/CameraSubTargetTurnParam.cpp @@ -4,20 +4,20 @@ namespace al { void CameraSubTargetTurnParam::init(const ActorInitInfo& info) { - tryGetArg(&mTurnSpeedRate1, info, "TurnSpeedRate1"); - tryGetArg(&mTurnSpeedRate2, info, "TurnSpeedRate2"); - tryGetArg(&mTurnBrakeEndDistance, info, "TurnBrakeEndDistance"); - tryGetArg(&mTurnBrakeStartDistance, info, "TurnBrakeStartDistance"); - tryGetArg(&mTurnStopStartDistance, info, "TurnStopStartDistance"); - tryGetArg(&mTurnStopEndDistance, info, "TurnStopEndDistance"); + tryGetArg(&turnSpeedRate1, info, "TurnSpeedRate1"); + tryGetArg(&turnSpeedRate2, info, "TurnSpeedRate2"); + tryGetArg(&turnBrakeEndDistance, info, "TurnBrakeEndDistance"); + tryGetArg(&turnBrakeStartDistance, info, "TurnBrakeStartDistance"); + tryGetArg(&turnStopStartDistance, info, "TurnStopStartDistance"); + tryGetArg(&turnStopEndDistance, info, "TurnStopEndDistance"); - if (tryGetArg(&mIsTurnV, info, "IsTurnV") && mIsTurnV) { - tryGetArg(&mIsResetAfterTurnV, info, "IsResetAfterTurnV"); - tryGetArg(&mMinTurnDegreeV, info, "MinTurnDegreeV"); - tryGetArg(&mMaxTurnDegreeV, info, "MaxTurnDegreeV"); + if (tryGetArg(&isTurnV, info, "IsTurnV") && isTurnV) { + tryGetArg(&isResetAfterTurnV, info, "IsResetAfterTurnV"); + tryGetArg(&minTurnDegreeV, info, "MinTurnDegreeV"); + tryGetArg(&maxTurnDegreeV, info, "MaxTurnDegreeV"); } - tryGetArg(&mValidTurnDegreeRangeH, info, "ValidTurnDegreeRangeH"); - tryGetArg(&mValidFaceDegreeRangeH, info, "ValidFaceDegreeRangeH"); + tryGetArg(&validTurnDegreeRangeH, info, "ValidTurnDegreeRangeH"); + tryGetArg(&validFaceDegreeRangeH, info, "ValidFaceDegreeRangeH"); } } // namespace al diff --git a/lib/al/Project/Camera/CameraSubTargetTurnParam.h b/lib/al/Project/Camera/CameraSubTargetTurnParam.h index df2699d010..b84f8f8f1e 100644 --- a/lib/al/Project/Camera/CameraSubTargetTurnParam.h +++ b/lib/al/Project/Camera/CameraSubTargetTurnParam.h @@ -5,51 +5,25 @@ namespace al { struct ActorInitInfo; -class CameraSubTargetTurnParam { -public: +struct CameraSubTargetTurnParam { CameraSubTargetTurnParam() {} void init(const ActorInitInfo& info); - f32 getValidTurnDegreeRangeH() const { return mValidTurnDegreeRangeH; } - - f32 getValidFaceDegreeRangeH() const { return mValidFaceDegreeRangeH; } - - f32 getTurnSpeedRate1() const { return mTurnSpeedRate1; } - - f32 getTurnSpeedRate2() const { return mTurnSpeedRate2; } - - s32 getTargetTurnRestartStep() const { return mTargetTurnRestartStep; } - - f32 getTurnStopStartDistance() const { return mTurnStopStartDistance; } - - f32 getTurnBrakeEndDistance() const { return mTurnBrakeEndDistance; } - - f32 getTurnBrakeStartDistance() const { return mTurnBrakeStartDistance; } - - f32 getTurnStopEndDistance() const { return mTurnStopEndDistance; } - - bool isTurnV() const { return mIsTurnV; } - - bool isResetAfterTurnV() const { return mIsResetAfterTurnV; } - - f32 getMinTurnDegreeV() const { return mMinTurnDegreeV; } - - f32 getMaxTurnDegreeV() const { return mMaxTurnDegreeV; } - -private: - f32 mTurnSpeedRate1 = 0.3f; - f32 mTurnSpeedRate2 = 0.1f; - f32 mTurnBrakeEndDistance = -1.0f; - f32 mTurnBrakeStartDistance = -1.0f; - f32 mTurnStopStartDistance = -1.0f; - f32 mTurnStopEndDistance = -1.0f; - s32 mTargetTurnRestartStep = 30; - bool mIsTurnV = false; - bool mIsResetAfterTurnV = false; - f32 mMinTurnDegreeV = 0.0f; - f32 mMaxTurnDegreeV = 0.0f; - f32 mValidTurnDegreeRangeH = -1.0f; - f32 mValidFaceDegreeRangeH = -1.0f; + f32 turnSpeedRate1 = 0.3f; + f32 turnSpeedRate2 = 0.1f; + f32 turnBrakeEndDistance = -1.0f; + f32 turnBrakeStartDistance = -1.0f; + f32 turnStopStartDistance = -1.0f; + f32 turnStopEndDistance = -1.0f; + s32 targetTurnRestartStep = 30; + bool isTurnV = false; + bool isResetAfterTurnV = false; + f32 minTurnDegreeV = 0.0f; + f32 maxTurnDegreeV = 0.0f; + f32 validTurnDegreeRangeH = -1.0f; + f32 validFaceDegreeRangeH = -1.0f; }; + +static_assert(sizeof(CameraSubTargetTurnParam) == 0x30); } // namespace al From 1d7b7f4a2150ef531e912a4bd4f08f2e440a1a9f Mon Sep 17 00:00:00 2001 From: Narr the Reg <5944268+german77@users.noreply.github.com> Date: Sun, 5 Jul 2026 16:31:21 -0600 Subject: [PATCH 3/7] Implement remaining functions --- data/file_list.yml | 218 ++--- lib/al/Library/Camera/CameraFlagCtrl.h | 4 +- lib/al/Library/Camera/CameraLimitRailKeeper.h | 2 + lib/al/Library/Camera/CameraPoser.h | 26 +- lib/al/Library/Camera/CameraPoserFunction.cpp | 849 +++++++++++++++--- lib/al/Library/Camera/CameraPoserFunction.h | 170 ++-- lib/al/Library/Camera/CameraPoserSceneInfo.h | 1 + .../Library/Camera/CameraRequestParamHolder.h | 3 + lib/al/Library/Camera/CameraTargetHolder.cpp | 6 +- lib/al/Library/Camera/CameraTargetHolder.h | 15 +- lib/al/Library/Camera/CameraTriangleFilter.h | 28 + lib/al/Library/Camera/CameraUtil.h | 2 +- lib/al/Library/Camera/CameraViewCtrlGyro.h | 30 +- lib/al/Library/Camera/CameraViewInfo.h | 8 +- lib/al/Library/Camera/SnapShotCameraCtrl.h | 26 +- lib/al/Library/Collision/KCollisionServer.h | 12 +- lib/al/Library/Obj/CameraRailHolder.h | 4 + lib/al/Project/Camera/CameraAngleCtrlInfo.h | 19 +- .../Camera/CameraCollisionPartsFilter.h | 16 + src/Player/PlayerJudgeSleep.h | 4 +- 20 files changed, 1107 insertions(+), 336 deletions(-) create mode 100644 lib/al/Library/Camera/CameraTriangleFilter.h create mode 100644 lib/al/Project/Camera/CameraCollisionPartsFilter.h diff --git a/data/file_list.yml b/data/file_list.yml index 2baf0ca748..8304f1ff70 100644 --- a/data/file_list.yml +++ b/data/file_list.yml @@ -228815,7 +228815,7 @@ Library/Camera/CameraPoserFunction.o: - offset: 0x834208 size: 24 label: _ZN21alCameraPoserFunction16getProjectionMtxEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x834220 size: 8 label: _ZN21alCameraPoserFunction7getNearEPKN2al11CameraPoserE @@ -229223,299 +229223,299 @@ Library/Camera/CameraPoserFunction.o: - offset: 0x8359a8 size: 36 label: _ZN21alCameraPoserFunction19initCameraMoveLimitEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8359cc size: 48 label: _ZN21alCameraPoserFunction19initCameraAngleCtrlEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8359fc size: 36 label: _ZN21alCameraPoserFunction32initCameraAngleCtrlWithRelativeHEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835a20 size: 16 label: _ZN21alCameraPoserFunction28initCameraDefaultAngleRangeVEPN2al11CameraPoserEff - status: NotDecompiled + status: Matching - offset: 0x835a30 size: 12 label: _ZN21alCameraPoserFunction20setCameraStartAngleVEPN2al11CameraPoserEf - status: NotDecompiled + status: Matching - offset: 0x835a3c size: 8 label: _ZN21alCameraPoserFunction15setCameraAngleVEPN2al11CameraPoserEf - status: NotDecompiled + status: Matching - offset: 0x835a44 size: 12 label: _ZN21alCameraPoserFunction15getCameraAngleHEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835a50 size: 12 label: _ZN21alCameraPoserFunction15getCameraAngleVEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835a5c size: 48 label: _ZN21alCameraPoserFunction14initAngleSwingEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835a8c size: 20 label: _ZN21alCameraPoserFunction17isValidAngleSwingEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835aa0 size: 48 label: _ZN21alCameraPoserFunction26initCameraOffsetCtrlPresetEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835ad0 size: 32 label: _ZN21alCameraPoserFunction9getOffsetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835af0 size: 48 label: _ZN21alCameraPoserFunction18initGyroCameraCtrlEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835b20 size: 96 label: _ZN21alCameraPoserFunction9resetGyroEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835b80 size: 84 label: _ZN21alCameraPoserFunction18calcCameraGyroPoseEPKN2al11CameraPoserEPN4sead7Vector3IfEES7_S7_ - status: NotDecompiled + status: Matching - offset: 0x835bd4 size: 12 label: _ZN21alCameraPoserFunction12getGyroFrontEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835be0 size: 12 label: _ZN21alCameraPoserFunction13getGyroAngleVEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835bec size: 12 label: _ZN21alCameraPoserFunction13getGyroAngleHEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835bf8 size: 16 label: _ZN21alCameraPoserFunction18setGyroLimitAngleVEPN2al11CameraPoserEff - status: NotDecompiled + status: Matching - offset: 0x835c08 size: 16 label: _ZN21alCameraPoserFunction18setGyroSensitivityEPN2al11CameraPoserEff - status: NotDecompiled + status: Matching - offset: 0x835c18 size: 8 label: _ZN21alCameraPoserFunction21reduceGyroSencitivityEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835c20 size: 16 label: _ZN21alCameraPoserFunction14stopUpdateGyroEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835c30 size: 12 label: _ZN21alCameraPoserFunction17restartUpdateGyroEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835c3c size: 12 label: _ZN21alCameraPoserFunction16isStopUpdateGyroEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835c48 size: 52 label: _ZN21alCameraPoserFunction21isTargetCollideGroundEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835c7c size: 52 label: _ZN21alCameraPoserFunction15isTargetInWaterEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835cb0 size: 52 label: _ZN21alCameraPoserFunction21isTargetInMoonGravityEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835ce4 size: 52 label: _ZN21alCameraPoserFunction17isTargetClimbPoleEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835d18 size: 52 label: _ZN21alCameraPoserFunction16isTargetGrabCeilEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835d4c size: 52 label: _ZN21alCameraPoserFunction26isTargetInvalidMoveByInputEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835d80 size: 88 label: _ZN21alCameraPoserFunction31isTargetEnableEndAfterInterpoleEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835dd8 size: 52 label: _ZN21alCameraPoserFunction17isTargetWallCatchEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835e0c size: 24 label: _ZN21alCameraPoserFunction14isSnapShotModeEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835e24 size: 68 label: _ZN21alCameraPoserFunction22initSnapShotCameraCtrlEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835e68 size: 80 label: _ZN21alCameraPoserFunction35initSnapShotCameraCtrlZoomAutoResetEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835eb8 size: 84 label: _ZN21alCameraPoserFunction34initSnapShotCameraCtrlZoomRollMoveEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835f0c size: 16 label: _ZN21alCameraPoserFunction34validateSnapShotCameraLookAtOffsetEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835f1c size: 16 label: _ZN21alCameraPoserFunction30validateSnapShotCameraZoomFovyEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835f2c size: 16 label: _ZN21alCameraPoserFunction26validateSnapShotCameraRollEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835f3c size: 188 label: _ZN21alCameraPoserFunction24updateSnapShotCameraCtrlEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x835ff8 size: 8 label: _ZN21alCameraPoserFunction28startResetSnapShotCameraCtrlEPN2al11CameraPoserEi - status: NotDecompiled + status: Matching - offset: 0x836000 size: 12 label: _ZN21alCameraPoserFunction31setSnapShotMaxZoomOutFovyDegreeEPN2al11CameraPoserEf - status: NotDecompiled + status: Matching - offset: 0x83600c size: 12 label: _ZN21alCameraPoserFunction21getSnapShotRollDegreeEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836018 size: 12 label: _ZN21alCameraPoserFunction23getSnapShotLookAtOffsetEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836024 size: 12 label: _ZN21alCameraPoserFunction19isOffVerticalAbsorbEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836030 size: 12 label: _ZN21alCameraPoserFunction16onVerticalAbsorbEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83603c size: 16 label: _ZN21alCameraPoserFunction17offVerticalAbsorbEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83604c size: 16 label: _ZN21alCameraPoserFunction20invalidateCameraBlurEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83605c size: 8 label: _ZN21alCameraPoserFunction27isRequestStopVerticalAbsorbERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x836064 size: 8 label: _ZN21alCameraPoserFunction22isRequestResetPositionERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x83606c size: 8 label: _ZN21alCameraPoserFunction20isRequestResetAngleVERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x836074 size: 8 label: _ZN21alCameraPoserFunction34isRequestDownToDefaultAngleBySpeedERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x83607c size: 8 label: _ZN21alCameraPoserFunction31isRequestUpToTargetAngleBySpeedERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x836084 size: 8 label: _ZN21alCameraPoserFunction22getRequestTargetAngleVERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x83608c size: 8 label: _ZN21alCameraPoserFunction20getRequestAngleSpeedERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x836094 size: 8 label: _ZN21alCameraPoserFunction23isRequestMoveDownAngleVERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x83609c size: 8 label: _ZN21alCameraPoserFunction18isRequestSetAngleVERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x8360a4 size: 8 label: _ZN21alCameraPoserFunction16getRequestAngleVERKN2al23CameraObjectRequestInfoE - status: NotDecompiled + status: Matching - offset: 0x8360ac size: 12 label: _ZN21alCameraPoserFunction17isInvalidColliderEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8360b8 size: 12 label: _ZN21alCameraPoserFunction16validateColliderEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8360c4 size: 16 label: _ZN21alCameraPoserFunction18invalidateColliderEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8360d4 size: 16 label: _ZN21alCameraPoserFunction22validateCtrlSubjectiveEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8360e4 size: 16 label: _ZN21alCameraPoserFunction26invalidateChangeSubjectiveEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8360f4 size: 16 label: _ZN21alCameraPoserFunction32invalidateKeepDistanceNextCameraEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836104 size: 16 label: _ZN21alCameraPoserFunction43invalidateKeepDistanceNextCameraIfNoCollideEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836114 size: 16 label: _ZN21alCameraPoserFunction36invalidatePreCameraEndAfterInterpoleEPN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836124 size: 12 label: _ZN21alCameraPoserFunction35isInvalidPreCameraEndAfterInterpoleEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836130 size: 12 label: _ZN21alCameraPoserFunction22isSceneCameraFirstCalcEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83613c size: 12 label: _ZN21alCameraPoserFunction17isActiveInterpoleEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836148 size: 24 label: _ZN21alCameraPoserFunction26isInvalidEndEntranceCameraEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836160 size: 8 label: _ZN21alCameraPoserFunction7isPauseEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836168 size: 216 label: _ZN21alCameraPoserFunction30checkFirstCameraCollisionArrowEPN4sead7Vector3IfEES3_PKN2al13IUseCollisionERKS2_S9_ - status: NotDecompiled + status: Matching - offset: 0x836240 size: 160 label: _ZN21alCameraPoserFunction30checkFirstCameraCollisionArrowEPNS_24CameraCollisionHitResultEPKN2al13IUseCollisionERKN4sead7Vector3IfEESA_ - status: NotDecompiled + status: Matching - offset: 0x8362e0 size: 192 label: _ZN21alCameraPoserFunction41checkFirstCameraCollisionArrowOnlyCeilingEPN4sead7Vector3IfEES3_PKN2al13IUseCollisionERKS2_S9_ - status: NotDecompiled + status: Matching - offset: 0x8363a0 size: 1044 label: _ZN21alCameraPoserFunction30checkCameraCollisionMoveSphereEPN4sead7Vector3IfEEPKN2al13IUseCollisionERKS2_S9_f @@ -229523,27 +229523,27 @@ Library/Camera/CameraPoserFunction.o: - offset: 0x8367b4 size: 148 label: _ZN21alCameraPoserFunction20calcZoneRotateAngleHEfPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836848 size: 148 label: _ZN21alCameraPoserFunction20calcZoneRotateAngleHEfRKN4sead8Matrix34IfEE - status: NotDecompiled + status: Matching - offset: 0x8368dc size: 156 label: _ZN21alCameraPoserFunction23calcZoneInvRotateAngleHEfRKN4sead8Matrix34IfEE - status: NotDecompiled + status: Matching - offset: 0x836978 size: 120 label: _ZN21alCameraPoserFunction11multVecZoneEPN4sead7Vector3IfEERKS2_PKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8369f0 size: 216 label: _ZN21alCameraPoserFunction14multVecInvZoneEPN4sead7Vector3IfEERKS2_PKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836ac8 size: 108 label: _ZN21alCameraPoserFunction13rotateVecZoneEPN4sead7Vector3IfEERKS2_PKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x836b34 size: 788 label: _ZN21alCameraPoserFunction28calcOffsetCameraKeepInFrameVEPN4sead7Vector3IfEEPNS0_12LookAtCameraERKS2_PKN2al11CameraPoserEff @@ -229551,111 +229551,111 @@ Library/Camera/CameraPoserFunction.o: - offset: 0x836e48 size: 148 label: _ZN21alCameraPoserFunction22makeCameraKeepInFrameVEPN4sead12LookAtCameraERKNS0_7Vector3IfEEPKN2al11CameraPoserEff - status: NotDecompiled + status: Matching - offset: 0x836edc size: 88 label: _ZN21alCameraPoserFunction14initCameraRailEPN2al11CameraPoserERKNS0_13PlacementInfoEPKc - status: NotDecompiled + status: Matching - offset: 0x836f34 size: 112 label: _ZN21alCameraPoserFunction19tryGetCameraRailArgEPfRKN2al13PlacementInfoEPKcS6_ - status: NotDecompiled + status: Matching - offset: 0x836fa4 size: 76 label: _ZN21alCameraPoserFunction23getCameraRailPointObjIdEPKN2al11CameraPoserEi - status: NotDecompiled + status: Matching - offset: 0x836ff0 size: 320 label: _ZN21alCameraPoserFunction29tryFindNearestLimitRailKeeperEPKN2al11CameraPoserERKN4sead7Vector3IfEE - status: NotDecompiled + status: Matching - offset: 0x837130 size: 124 label: _ZN21alCameraPoserFunction21calcCameraRotateStickEPN4sead7Vector2IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8371ac size: 124 label: _ZN21alCameraPoserFunction22calcCameraRotateStickHEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837228 size: 120 label: _ZN21alCameraPoserFunction22calcCameraRotateStickVEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8372a0 size: 156 label: _ZN21alCameraPoserFunction26calcCameraRotateStickPowerEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83733c size: 16 label: _ZN21alCameraPoserFunction24getStickSensitivityLevelEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83734c size: 48 label: _ZN21alCameraPoserFunction24getStickSensitivityScaleEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83737c size: 32 label: _ZN21alCameraPoserFunction11isValidGyroEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83739c size: 16 label: _ZN21alCameraPoserFunction23getGyroSensitivityLevelEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8373ac size: 48 label: _ZN21alCameraPoserFunction23getGyroSensitivityScaleEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8373dc size: 84 label: _ZN21alCameraPoserFunction26isTriggerCameraResetRotateEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837430 size: 52 label: _ZN21alCameraPoserFunction16isHoldCameraZoomEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837464 size: 52 label: _ZN21alCameraPoserFunction26isHoldCameraSnapShotZoomInEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837498 size: 52 label: _ZN21alCameraPoserFunction27isHoldCameraSnapShotZoomOutEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8374cc size: 52 label: _ZN21alCameraPoserFunction28isHoldCameraSnapShotRollLeftEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837500 size: 52 label: _ZN21alCameraPoserFunction29isHoldCameraSnapShotRollRightEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837534 size: 64 label: _ZN21alCameraPoserFunction30tryCalcCameraSnapShotMoveStickEPN4sead7Vector2IfEEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837574 size: 12 label: _ZN21alCameraPoserFunction17isPlayerTypeFlyerEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837580 size: 12 label: _ZN21alCameraPoserFunction25isPlayerTypeHighSpeedMoveEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x83758c size: 12 label: _ZN21alCameraPoserFunction20isPlayerTypeHighJumpEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x837598 size: 12 label: _ZN21alCameraPoserFunction26isPlayerTypeNotTouchGroundEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8375a4 size: 40 label: _ZN21alCameraPoserFunction11isOnRideObjEPKN2al11CameraPoserE - status: NotDecompiled + status: Matching - offset: 0x8375cc size: 100 - label: '' - status: NotDecompiled + label: _GLOBAL__sub_I_CameraPoserFunction.cpp + status: Matching Library/Camera/CameraPoserSceneInfo.o: '.text': - offset: 0x837630 diff --git a/lib/al/Library/Camera/CameraFlagCtrl.h b/lib/al/Library/Camera/CameraFlagCtrl.h index c715ff73cc..030686f97f 100644 --- a/lib/al/Library/Camera/CameraFlagCtrl.h +++ b/lib/al/Library/Camera/CameraFlagCtrl.h @@ -11,7 +11,9 @@ struct CameraFlagCtrl { bool isSnapShotModeRunning = false; bool isValidCameraAreaKids = false; bool isSeparatePlayMode = false; - bool _6 = false; + bool isInvalidEndEntranceCamera = false; }; +static_assert(sizeof(CameraFlagCtrl) == 0x7); + } // namespace al diff --git a/lib/al/Library/Camera/CameraLimitRailKeeper.h b/lib/al/Library/Camera/CameraLimitRailKeeper.h index ecba2f76b0..0dd9aa1941 100644 --- a/lib/al/Library/Camera/CameraLimitRailKeeper.h +++ b/lib/al/Library/Camera/CameraLimitRailKeeper.h @@ -21,6 +21,8 @@ class CameraLimitRailKeeper { f32 calcDistanceFromNearestRailPos(const sead::Vector3f& pos) const; void calcNearestRailPos(sead::Vector3f* out, const sead::Vector3f& pos) const; + f32 getActivateDistance() const { return mActivateDistance; } + private: Rail* mRail = nullptr; RailRider** mRiders = nullptr; diff --git a/lib/al/Library/Camera/CameraPoser.h b/lib/al/Library/Camera/CameraPoser.h index 3ef23728c3..993e653018 100644 --- a/lib/al/Library/Camera/CameraPoser.h +++ b/lib/al/Library/Camera/CameraPoser.h @@ -225,10 +225,22 @@ class CameraPoser : public HioNode, CameraOffsetCtrlPreset* getCameraOffsetCtrlPreset() const { return mOffsetCtrlPreset; } - CameraPoserSceneInfo* getCameraPoserSceneInfo() const { return mSceneInfo; } + CameraPoserSceneInfo* getSceneInfo() const { return mSceneInfo; } CameraVerticalAbsorber* getCameraVerticalAbsorber() const { return mVerticalAbsorber; } + CameraAngleCtrlInfo* getAngleCtrlInfo() const { return mAngleCtrlInfo; } + + CameraAngleSwingInfo* getAngleSwingInfo() const { return mAngleSwingInfo; } + + CameraOffsetCtrlPreset* getOffsetCtrlPreset() const { return mOffsetCtrlPreset; } + + GyroCameraCtrl* getGyroCtrl() const { return mGyroCtrl; } + + CameraPoserFlag* getPoserFag() const { return mPoserFlag; } + + SnapShotCameraCtrl* getSnapShotCtrl() const { return mSnapShotCtrl; } + // set void setEye(const sead::Vector3f& pos) { mEye.set(pos); } @@ -246,6 +258,18 @@ class CameraPoser : public HioNode, mVerticalAbsorber = cameraVerticalAbsorber; } + void setParamMoveLimit(CameraParamMoveLimit* param) { mParamMoveLimit = param; } + + void setAngleCtrlInfo(CameraAngleCtrlInfo* angleCtrlInfo) { mAngleCtrlInfo = angleCtrlInfo; } + + void setAngleSwingInfo(CameraAngleSwingInfo* info) { mAngleSwingInfo = info; } + + void setOffsetCtrlPreset(CameraOffsetCtrlPreset* preset) { mOffsetCtrlPreset = preset; } + + void setGyroCtrl(GyroCameraCtrl* gyroCtrl) { mGyroCtrl = gyroCtrl; } + + void setSnapShotCtrl(SnapShotCameraCtrl* ctrl) { mSnapShotCtrl = ctrl; } + protected: const char* mPoserName; ActiveState mActiveState = ActiveState::Start; diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp index ebe83ca469..073aad65be 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.cpp +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -2,9 +2,14 @@ #include "Library/Base/StringUtil.h" #include "Library/Camera/CameraArrowCollider.h" +#include "Library/Camera/CameraFlagCtrl.h" +#include "Library/Camera/CameraInputHolder.h" +#include "Library/Camera/CameraLimitRailKeeper.h" #include "Library/Camera/CameraOffsetCtrlPreset.h" +#include "Library/Camera/CameraParamMoveLimit.h" #include "Library/Camera/CameraPoser.h" #include "Library/Camera/CameraPoserFix.h" +#include "Library/Camera/CameraPoserFlag.h" #include "Library/Camera/CameraPoserSceneInfo.h" #include "Library/Camera/CameraRequestParamHolder.h" #include "Library/Camera/CameraStartInfo.h" @@ -12,20 +17,72 @@ #include "Library/Camera/CameraTargetBase.h" #include "Library/Camera/CameraTargetCollideInfoHolder.h" #include "Library/Camera/CameraTargetHolder.h" +#include "Library/Camera/CameraTriangleFilter.h" +#include "Library/Camera/CameraViewCtrlGyro.h" #include "Library/Camera/CameraViewInfo.h" +#include "Library/Camera/SimpleCameraInput.h" +#include "Library/Camera/SnapShotCameraCtrl.h" +#include "Library/Collision/CollisionPartsKeeperUtil.h" +#include "Library/Collision/CollisionPartsTriangle.h" +#include "Library/Collision/PartsInterpolator.h" #include "Library/Math/MathUtil.h" +#include "Library/Obj/CameraRailHolder.h" +#include "Library/Placement/PlacementFunction.h" +#include "Library/Placement/PlacementId.h" +#include "Library/Placement/PlacementInfo.h" #include "Library/Play/Camera/CameraVerticalAbsorber.h" #include "Library/Projection/Projection.h" +#include "Library/Rail/RailUtil.h" +#include "Project/Camera/CameraAngleCtrlInfo.h" +#include "Project/Camera/CameraAngleSwingInfo.h" +#include "Project/Camera/CameraCollisionPartsFilter.h" +#include "Project/Camera/CameraObjectRequestInfo.h" #include "Project/Camera/CameraSubTargetTurnParam.h" namespace alCameraPoserFunction { +static al::CameraCollisionPartsFilter sPartsFiler; +static al::CameraTriangleFilter sTriangleFilter; +static al::CameraTriangleFilterOnlyCeiling sCeilFilter; +static sead::Vector3f sMtxX = {-1.0f, 0.0f, 0.0f}; +static sead::Vector3f sMtxY = {0.0f, 1.0f, 0.0f}; +static sead::Vector3f sMtxZ = {0.0f, 0.0f, -1.0f}; + +static inline s32 getViewInfoIndex(const al::CameraPoser* cameraPoser) { + return cameraPoser->getViewInfo()->getIndex(); +} -s32 getViewIndex(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getIndex(); +static inline al::CameraTargetBase* getTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getTargetHolder()->getViewTarget(getViewInfoIndex(cameraPoser)); } -static s32 getViewInfoIndex(const al::CameraPoser* cameraPoser) { - return cameraPoser->getViewInfo()->getIndex(); +static inline al::CameraTargetBase* tryGetTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getTargetHolder()->tryGetViewTarget(getViewInfoIndex(cameraPoser)); +} + +static inline al::CameraVerticalAbsorber* getVerticalAbsorber(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraVerticalAbsorber(); +} + +static inline al::CameraTargetCollideInfoHolder* +getTargetCollision(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->targetCollideInfoHolder; +} + +static inline al::ICameraInput* getCameraInput(const al::CameraPoser* cameraPoser) { + return cameraPoser->getInputHolder()->getInput(getViewInfoIndex(cameraPoser)); +} + +static inline al::CameraSubTargetBase* getTopSubTarget(const al::CameraPoser* cameraPoser) { + return cameraPoser->getTargetHolder()->getTopSubTarget(); +} + +static inline al::CameraSubTargetTurnParam* +getSubTargetTurnParam(const al::CameraPoser* cameraPoser) { + return getTopSubTarget(cameraPoser)->getSubTargetTurnParam(); +} + +s32 getViewIndex(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getIndex(); } const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser) { @@ -40,6 +97,10 @@ const al::Projection& getProjection(const al::CameraPoser* cameraPoser) { return cameraPoser->getCameraViewInfo()->getProjection(); } +const sead::Matrix44f& getProjectionMtx(const al::CameraPoser* cameraPoser) { + return cameraPoser->getCameraViewInfo()->getProjMtx(); +} + f32 getNear(const al::CameraPoser* cameraPoser) { return cameraPoser->getCameraViewInfo()->getNear(); } @@ -171,70 +232,70 @@ f32 getNextAngleVByPreCamera(const al::CameraStartInfo& cameraStartInfo) { return cameraStartInfo.nextAngleVByPreCamera; } -void calcCameraPose(sead::Quatf* out, const al::CameraPoser* cameraPoser) { +void calcCameraPose(sead::Quatf* outPose, const al::CameraPoser* cameraPoser) { sead::Vector3f lookDir; calcLookDir(&lookDir, cameraPoser); - al::makeQuatFrontUp(out, lookDir, cameraPoser->getUp()); + al::makeQuatFrontUp(outPose, lookDir, cameraPoser->getUp()); } -void calcLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - calcCameraDir(out, cameraPoser); - out->negate(); +void calcLookDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + calcCameraDir(outDir, cameraPoser); + outDir->negate(); } -void calcCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - out->setSub(cameraPoser->getEye(), cameraPoser->getAt()); - al::normalize(out); +void calcCameraDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + outDir->setSub(cameraPoser->getEye(), cameraPoser->getAt()); + al::normalize(outDir); } -bool calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - out->setSub(cameraPoser->getEye(), cameraPoser->getAt()); - al::verticalizeVec(out, cameraPoser->getUp(), *out); - return al::tryNormalizeOrZero(out); +bool calcCameraDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) { + outDirH->setSub(cameraPoser->getEye(), cameraPoser->getAt()); + al::verticalizeVec(outDirH, cameraPoser->getUp(), *outDirH); + return al::tryNormalizeOrZero(outDirH); } -bool calcLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - bool isValid = calcCameraDirH(out, cameraPoser); - out->negate(); +bool calcLookDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) { + bool isValid = calcCameraDirH(outDirH, cameraPoser); + outDirH->negate(); return isValid; } -void calcSideDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = cameraPoser->getEye() - cameraPoser->getAt(); - al::normalize(&vec); - out->set(vec.cross(cameraPoser->getUp())); - al::normalize(out); +void calcSideDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + sead::Vector3f facingDir = cameraPoser->getEye() - cameraPoser->getAt(); + al::normalize(&facingDir); + outDir->set(facingDir.cross(cameraPoser->getUp())); + al::normalize(outDir); } -void calcPreCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { +void calcPreCameraDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser); - out->setSub(lookAtCam.getPos(), lookAtCam.getAt()); - al::normalize(out); + outDir->setSub(lookAtCam.getPos(), lookAtCam.getAt()); + al::normalize(outDir); } -void calcPreCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { +void calcPreCameraDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) { const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser); - out->setSub(lookAtCam.getPos(), lookAtCam.getAt()); - al::verticalizeVec(out, sead::Vector3f::ey, *out); - al::tryNormalizeOrZero(out); + outDirH->setSub(lookAtCam.getPos(), lookAtCam.getAt()); + al::verticalizeVec(outDirH, sead::Vector3f::ey, *outDirH); + al::tryNormalizeOrZero(outDirH); } -void calcPreLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - calcPreCameraDir(out, cameraPoser); - out->negate(); +void calcPreLookDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + calcPreCameraDir(outDir, cameraPoser); + outDir->negate(); } -void calcPreLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { +void calcPreLookDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) { const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser); - out->set(lookAtCam.getAt() - lookAtCam.getPos()); - al::verticalizeVec(out, getPreUpDir(cameraPoser), *out); - al::tryNormalizeOrZero(out); + outDirH->set(lookAtCam.getAt() - lookAtCam.getPos()); + al::verticalizeVec(outDirH, getPreUpDir(cameraPoser), *outDirH); + al::tryNormalizeOrZero(outDirH); } f32 calcPreCameraAngleH(const al::CameraPoser* cameraPoser) { - sead::Vector3f vec = {0.0f, 0.0f, 0.0f}; - calcPreCameraDirH(&vec, cameraPoser); - return sead::Mathf::rad2deg(sead::Mathf::atan2(vec.x, vec.z)); + sead::Vector3f cameraDirH = {0.0f, 0.0f, 0.0f}; + calcPreCameraDirH(&cameraDirH, cameraPoser); + return sead::Mathf::rad2deg(sead::Mathf::atan2(cameraDirH.x, cameraDirH.z)); } f32 calcPreCameraAngleV(const al::CameraPoser* cameraPoser) { @@ -250,12 +311,8 @@ void setLookAtPosToTarget(al::CameraPoser* cameraPoser) { cameraPoser->setAt(targetTrans); } -static inline al::CameraTargetBase* getTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->getViewTarget(getViewInfoIndex(cameraPoser)); -} - -void calcTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTarget(cameraPoser)->calcTrans(out); +void calcTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser) { + getTarget(cameraPoser)->calcTrans(outTrans); } void setLookAtPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset) { @@ -276,26 +333,26 @@ void setCameraPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vec cameraPoser->setEye(targetTrans + offset); } -void calcTargetTransWithOffset(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - calcTargetTrans(out, cameraPoser); +void calcTargetTransWithOffset(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser) { + calcTargetTrans(outTrans, cameraPoser); al::CameraOffsetCtrlPreset* cameraOffsetCtrlPreset = cameraPoser->getCameraOffsetCtrlPreset(); if (cameraOffsetCtrlPreset) - out->add(cameraOffsetCtrlPreset->getOffset()); + outTrans->add(cameraOffsetCtrlPreset->getOffset()); } -void calcTargetVelocity(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTarget(cameraPoser)->calcVelocity(out); +void calcTargetVelocity(sead::Vector3f* outVelocity, const al::CameraPoser* cameraPoser) { + getTarget(cameraPoser)->calcVelocity(outVelocity); } -void calcTargetVelocityH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - calcTargetVelocity(out, cameraPoser); - sead::Vector3f vec = sead::Vector3f::ey; - calcTargetUp(&vec, cameraPoser); - al::verticalizeVec(out, vec, *out); +void calcTargetVelocityH(sead::Vector3f* outVelocityH, const al::CameraPoser* cameraPoser) { + calcTargetVelocity(outVelocityH, cameraPoser); + sead::Vector3f up = sead::Vector3f::ey; + calcTargetUp(&up, cameraPoser); + al::verticalizeVec(outVelocityH, up, *outVelocityH); } -void calcTargetUp(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTarget(cameraPoser)->calcUp(out); +void calcTargetUp(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + getTarget(cameraPoser)->calcUp(outDir); } f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser) { @@ -314,24 +371,24 @@ f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser) { return -speedV; } -void calcTargetPose(sead::Quatf* out, const al::CameraPoser* cameraPoser) { +void calcTargetPose(sead::Quatf* outPose, const al::CameraPoser* cameraPoser) { sead::Vector3f targetUp = {0.0f, 0.0f, 0.0f}; sead::Vector3f targetFront = {0.0f, 0.0f, 0.0f}; calcTargetUp(&targetUp, cameraPoser); calcTargetFront(&targetFront, cameraPoser); - al::makeQuatFrontUp(out, targetFront, targetUp); + al::makeQuatFrontUp(outPose, targetFront, targetUp); } -void calcTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTarget(cameraPoser)->calcFront(out); +void calcTargetFront(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + getTarget(cameraPoser)->calcFront(outDir); } -void calcTargetSide(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTarget(cameraPoser)->calcSide(out); +void calcTargetSide(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + getTarget(cameraPoser)->calcSide(outDir); } -void calcTargetGravity(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTarget(cameraPoser)->calcGravity(out); +void calcTargetGravity(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + getTarget(cameraPoser)->calcGravity(outDir); } f32 calcTargetSpeedH(const al::CameraPoser* cameraPoser) { @@ -374,11 +431,11 @@ bool isChangeTarget(const al::CameraPoser* cameraPoser) { return cameraPoser->getTargetHolder()->isChangeViewTarget(getViewInfoIndex(cameraPoser)); } -bool tryGetTargetRequestDistance(f32* out, const al::CameraPoser* cameraPoser) { +bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* cameraPoser) { al::CameraTargetBase* target = getTarget(cameraPoser); if (target->getRequestDistance() > 0.0f) { - *out = target->getRequestDistance(); + *outDistance = target->getRequestDistance(); return true; } @@ -386,16 +443,11 @@ bool tryGetTargetRequestDistance(f32* out, const al::CameraPoser* cameraPoser) { } f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo()->requestParamHolder->get_60(); + return cameraPoser->getSceneInfo()->requestParamHolder->get_60(); } f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo()->requestParamHolder->get_58(); -} - -static inline al::CameraTargetCollideInfoHolder* -getTargetCollision(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraPoserSceneInfo()->targetCollideInfoHolder; + return cameraPoser->getSceneInfo()->requestParamHolder->get_58(); } bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser) { @@ -419,8 +471,9 @@ bool isExistWallCollisionUnderTarget(const al::CameraPoser* cameraPoser) { return getTargetCollision(cameraPoser)->isExistUnderWall(); } -bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - return getTargetCollision(cameraPoser)->tryCalcSlopDownFrontDirH(out); +bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* outDirH, + const al::CameraPoser* cameraPoser) { + return getTargetCollision(cameraPoser)->tryCalcSlopDownFrontDirH(outDirH); } f32 getSlopeCollisionUpSpeed(const al::CameraPoser* cameraPoser) { @@ -432,16 +485,7 @@ f32 getSlopeCollisionDownSpeed(const al::CameraPoser* cameraPoser) { } bool isExistSubTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->getTopSubTargetInline(); -} - -static inline al::CameraSubTargetBase* getTopSubTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->getTopSubTarget(); -} - -static inline al::CameraSubTargetTurnParam* -getSubTargetTurnParam(const al::CameraPoser* cameraPoser) { - return getTopSubTarget(cameraPoser)->getSubTargetTurnParam(); + return cameraPoser->getTargetHolder()->getTopSubTargetInfo().target; } bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser) { @@ -480,21 +524,21 @@ bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser) { return true; } -void calcSubTargetBack(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - calcSubTargetFront(out, cameraPoser); - out->negate(); +void calcSubTargetBack(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + calcSubTargetFront(outDir, cameraPoser); + outDir->negate(); } -void calcSubTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTopSubTarget(cameraPoser)->calcTrans(out); +void calcSubTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser) { + getTopSubTarget(cameraPoser)->calcTrans(outTrans); } bool isChangeSubTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->hasTopSubTargetChanged(); + return cameraPoser->getTargetHolder()->getTopSubTargetInfo().hasTargetChanged; } -void calcSubTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser) { - getTopSubTarget(cameraPoser)->calcFront(out); +void calcSubTargetFront(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { + getTopSubTarget(cameraPoser)->calcFront(outDir); } f32 getSubTargetRequestDistance(const al::CameraPoser* cameraPoser) { @@ -513,30 +557,31 @@ s32 getSubTargetTurnRestartStep(const al::CameraPoser* cameraPoser) { return getSubTargetTurnParam(cameraPoser)->targetTurnRestartStep; } -bool tryCalcSubTargetTurnBrakeDistanceRate(f32* out, const al::CameraPoser* cameraPoser) { +bool tryCalcSubTargetTurnBrakeDistanceRate(f32* outDistanceRate, + const al::CameraPoser* cameraPoser) { al::CameraSubTargetTurnParam* turnParam = getSubTargetTurnParam(cameraPoser); - sead::Vector3f vec = {0.0f, 0.0f, 0.0f}; - sead::Vector3f vec2 = {0.0f, 0.0f, 0.0f}; - calcTargetTrans(&vec, cameraPoser); - calcSubTargetTrans(&vec2, cameraPoser); + sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f}; + sead::Vector3f subTargetTrans = {0.0f, 0.0f, 0.0f}; + calcTargetTrans(&targetTrans, cameraPoser); + calcSubTargetTrans(&subTargetTrans, cameraPoser); - f32 distance = sead::Mathf::sqrt(sead::Mathf::pow(vec.x - vec2.x, 2) + - sead::Mathf::pow(vec.z - vec2.z, 2)); + f32 distance = sead::Mathf::sqrt(sead::Mathf::pow(targetTrans.x - subTargetTrans.x, 2) + + sead::Mathf::pow(targetTrans.z - subTargetTrans.z, 2)); if (turnParam->turnBrakeEndDistance > 0.0f && turnParam->turnBrakeEndDistance < turnParam->turnBrakeStartDistance && distance < turnParam->turnBrakeStartDistance) { - *out = 1.0f - al::normalize(distance, turnParam->turnBrakeEndDistance, - turnParam->turnBrakeStartDistance); + *outDistanceRate = 1.0f - al::normalize(distance, turnParam->turnBrakeEndDistance, + turnParam->turnBrakeStartDistance); return true; } if (turnParam->turnStopStartDistance > 0.0f && turnParam->turnStopStartDistance < turnParam->turnStopEndDistance && turnParam->turnStopStartDistance < distance) { - *out = al::normalize(distance, turnParam->turnStopStartDistance, - turnParam->turnStopEndDistance); + *outDistanceRate = al::normalize(distance, turnParam->turnStopStartDistance, + turnParam->turnStopEndDistance); return true; } @@ -551,12 +596,12 @@ bool isValidSubTargetResetAfterTurnV(const al::CameraPoser* cameraPoser) { return getSubTargetTurnParam(cameraPoser)->isResetAfterTurnV; } -void clampAngleSubTargetTurnRangeV(f32* out, const al::CameraPoser* cameraPoser) { +void clampAngleSubTargetTurnRangeV(f32* outTurnRangeV, const al::CameraPoser* cameraPoser) { al::CameraSubTargetBase* topSubTarget = getTopSubTarget(cameraPoser); f32 min = topSubTarget->getSubTargetTurnParam()->minTurnDegreeV; f32 max = topSubTarget->getSubTargetTurnParam()->maxTurnDegreeV; - *out = sead::Mathf::clamp(*out, min, max); + *outTurnRangeV = sead::Mathf::clamp(*outTurnRangeV, min, max); } void initCameraVerticalAbsorber(al::CameraPoser* cameraPoser) { @@ -567,10 +612,6 @@ void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser* cameraPoser) { cameraPoser->setVerticalAbsorber(new al::CameraVerticalAbsorber(cameraPoser, true)); } -static inline al::CameraVerticalAbsorber* getVerticalAbsorber(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraVerticalAbsorber(); -} - f32 getCameraVerticalAbsorbPosUp(const al::CameraPoser* cameraPoser) { return getVerticalAbsorber(cameraPoser)->getAbsorbScreenPosUp(); } @@ -628,4 +669,586 @@ void initCameraArrowColliderWithoutThroughPassCollision(al::CameraPoser* cameraP cameraPoser->initArrowCollider(cameraArrowCollider); } +void initCameraMoveLimit(al::CameraPoser* cameraPoser) { + cameraPoser->setParamMoveLimit(al::CameraParamMoveLimit::create(cameraPoser)); +} + +void initCameraAngleCtrl(al::CameraPoser* cameraPoser) { + cameraPoser->setAngleCtrlInfo(new al::CameraAngleCtrlInfo()); +} + +void initCameraAngleCtrlWithRelativeH(al::CameraPoser* cameraPoser) { + cameraPoser->setAngleCtrlInfo(al::CameraAngleCtrlInfo::createWithRelativeH()); +} + +void initCameraDefaultAngleRangeV(al::CameraPoser* cameraPoser, f32 min, f32 max) { + cameraPoser->getAngleCtrlInfo()->setDefaultAngleV(min, max); +} + +void setCameraStartAngleV(al::CameraPoser* cameraPoser, f32 angle) { + cameraPoser->getAngleCtrlInfo()->setStartAngleV(angle); +} + +void setCameraAngleV(al::CameraPoser* cameraPoser, f32 angle) { + cameraPoser->getAngleCtrlInfo()->setAngleV(angle); +} + +f32 getCameraAngleH(const al::CameraPoser* cameraPoser) { + return cameraPoser->getAngleCtrlInfo()->getAngleH(); +} + +f32 getCameraAngleV(const al::CameraPoser* cameraPoser) { + return cameraPoser->getAngleCtrlInfo()->getAngleV(); +} + +void initAngleSwing(al::CameraPoser* cameraPoser) { + cameraPoser->setAngleSwingInfo(new al::CameraAngleSwingInfo()); +} + +bool isValidAngleSwing(const al::CameraPoser* cameraPoser) { + return !cameraPoser->getAngleSwingInfo()->isInvalidSwing(); +} + +void initCameraOffsetCtrlPreset(al::CameraPoser* cameraPoser) { + cameraPoser->setOffsetCtrlPreset(new al::CameraOffsetCtrlPreset()); +} + +const sead::Vector3f& getOffset(const al::CameraPoser* cameraPoser) { + return cameraPoser->getOffsetCtrlPreset()->getOffset(); +} + +void initGyroCameraCtrl(al::CameraPoser* cameraPoser) { + cameraPoser->setGyroCtrl(new al::GyroCameraCtrl()); +} + +void resetGyro(al::CameraPoser* cameraPoser) { + sead::Vector3f gyroPoseX; + sead::Vector3f gyroPoseY; + sead::Vector3f gyroPoseZ; + calcCameraGyroPose(cameraPoser, &gyroPoseX, &gyroPoseY, &gyroPoseZ); + cameraPoser->getGyroCtrl()->reset(gyroPoseX, gyroPoseY, gyroPoseZ); +} + +void calcCameraGyroPose(const al::CameraPoser* cameraPoser, sead::Vector3f* gyroPoseX, + sead::Vector3f* gyroPoseY, sead::Vector3f* gyroPoseZ) { + getCameraInput(cameraPoser)->calcGyroPose(gyroPoseX, gyroPoseY, gyroPoseZ); +} + +const sead::Vector3f& getGyroFront(al::CameraPoser* cameraPoser) { + return cameraPoser->getGyroCtrl()->getFront(); +} + +f32 getGyroAngleV(al::CameraPoser* cameraPoser) { + return cameraPoser->getGyroCtrl()->getAngleV(); +} + +f32 getGyroAngleH(al::CameraPoser* cameraPoser) { + return cameraPoser->getGyroCtrl()->getAngleH(); +} + +void setGyroLimitAngleV(al::CameraPoser* cameraPoser, f32 min, f32 max) { + cameraPoser->getGyroCtrl()->setLimitAngleV(min, max); +} + +void setGyroSensitivity(al::CameraPoser* cameraPoser, f32 min, f32 max) { + cameraPoser->getGyroCtrl()->setSensitivity(min, max); +} + +void reduceGyroSencitivity(al::CameraPoser* cameraPoser) { + cameraPoser->getGyroCtrl()->reduceSensitivity(); +} + +void stopUpdateGyro(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isStopUpdateGyro = true; +} + +void restartUpdateGyro(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isStopUpdateGyro = false; +} + +bool isStopUpdateGyro(const al::CameraPoser* cameraPoser) { + return cameraPoser->getPoserFag()->isStopUpdateGyro; +} + +bool isTargetCollideGround(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isCollideGround(); +} + +bool isTargetInWater(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isInWater(); +} + +bool isTargetInMoonGravity(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isInMoonGravity(); +} + +bool isTargetClimbPole(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isClimbPole(); +} + +bool isTargetGrabCeil(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isGrabCeil(); +} + +bool isTargetInvalidMoveByInput(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isInvalidMoveByInput(); +} + +bool isTargetEnableEndAfterInterpole(const al::CameraPoser* cameraPoser) { + return tryGetTarget(cameraPoser) && getTarget(cameraPoser)->isEnableEndAfterInterpole(); +} + +bool isTargetWallCatch(const al::CameraPoser* cameraPoser) { + return getTarget(cameraPoser)->isWallCatch(); +} + +bool isSnapShotMode(const al::CameraPoser* cameraPoser) { + return cameraPoser->getFlagCtrl()->isSnapShotModeRunning; +} + +void initSnapShotCameraCtrl(al::CameraPoser* cameraPoser) { + al::SnapShotCameraSceneInfo* sceneInfo = cameraPoser->getSceneInfo()->snapShotCameraSceneInfo; + al::SnapShotCameraCtrl* snapShotCtrl = new al::SnapShotCameraCtrl(sceneInfo); + cameraPoser->setSnapShotCtrl(snapShotCtrl); +} + +void initSnapShotCameraCtrlZoomAutoReset(al::CameraPoser* cameraPoser) { + al::SnapShotCameraSceneInfo* sceneInfo = cameraPoser->getSceneInfo()->snapShotCameraSceneInfo; + al::SnapShotCameraCtrl* snapShotCtrl = new al::SnapShotCameraCtrl(sceneInfo); + snapShotCtrl->setIsValidZoomFovy(true); + snapShotCtrl->set_68(true); + cameraPoser->setSnapShotCtrl(snapShotCtrl); +} + +void initSnapShotCameraCtrlZoomRollMove(al::CameraPoser* cameraPoser) { + al::SnapShotCameraSceneInfo* sceneInfo = cameraPoser->getSceneInfo()->snapShotCameraSceneInfo; + al::SnapShotCameraCtrl* snapShotCtrl = new al::SnapShotCameraCtrl(sceneInfo); + snapShotCtrl->setIsValidZoomFovy(true); + snapShotCtrl->setIsValidRoll(true); + snapShotCtrl->setIsValidLookAtOffset(true); + cameraPoser->setSnapShotCtrl(snapShotCtrl); +} + +void validateSnapShotCameraLookAtOffset(al::CameraPoser* cameraPoser) { + cameraPoser->getSnapShotCtrl()->setIsValidLookAtOffset(true); +} + +void validateSnapShotCameraZoomFovy(al::CameraPoser* cameraPoser) { + cameraPoser->getSnapShotCtrl()->setIsValidZoomFovy(true); +} + +void validateSnapShotCameraRoll(al::CameraPoser* cameraPoser) { + cameraPoser->getSnapShotCtrl()->setIsValidRoll(true); +} + +void updateSnapShotCameraCtrl(al::CameraPoser* cameraPoser) { + sead::LookAtCamera camera; + cameraPoser->makeLookAtCameraPrev(&camera); + + cameraPoser->getSnapShotCtrl()->update(camera, cameraPoser, getCameraInput(cameraPoser)); +} + +void startResetSnapShotCameraCtrl(al::CameraPoser* cameraPoser, s32 value) { + cameraPoser->getSnapShotCtrl()->startReset(value); +} + +void setSnapShotMaxZoomOutFovyDegree(al::CameraPoser* cameraPoser, f32 value) { + cameraPoser->getSnapShotCtrl()->setMaxZoomOutFovyDegree(value); +} + +f32 getSnapShotRollDegree(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSnapShotCtrl()->getRollDegree(); +} + +const sead::Vector3f& getSnapShotLookAtOffset(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSnapShotCtrl()->getLookAtOffset(); +} + +bool isOffVerticalAbsorb(const al::CameraPoser* cameraPoser) { + return cameraPoser->getPoserFag()->isOffVerticalAbsorb; +} + +void onVerticalAbsorb(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isOffVerticalAbsorb = false; +} + +void offVerticalAbsorb(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isOffVerticalAbsorb = true; +} + +void invalidateCameraBlur(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidCameraBlur = true; +} + +bool isRequestStopVerticalAbsorb(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isStopVerticalAbsorb; +} + +bool isRequestResetPosition(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isResetPosition; +} + +bool isRequestResetAngleV(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isResetAngleV; +} + +bool isRequestDownToDefaultAngleBySpeed(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isDownToDefaultAngleBySpeed; +} + +bool isRequestUpToTargetAngleBySpeed(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isUpToTargetAngleBySpeed; +} + +f32 getRequestTargetAngleV(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.targetAngleV; +} + +f32 getRequestAngleSpeed(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.angleSpeed; +} + +bool isRequestMoveDownAngleV(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isMoveDownAngle; +} + +bool isRequestSetAngleV(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.isSetAngleV; +} + +f32 getRequestAngleV(const al::CameraObjectRequestInfo& requestInfo) { + return requestInfo.angleV; +} + +bool isInvalidCollider(const al::CameraPoser* cameraPoser) { + return cameraPoser->getPoserFag()->isInvalidCollider; +} + +void validateCollider(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidCollider = false; +} + +void invalidateCollider(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidCollider = true; +} + +void validateCtrlSubjective(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isValidCtrlSubjective = true; +} + +void invalidateChangeSubjective(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidChangeSubjective = true; +} + +void invalidateKeepDistanceNextCamera(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidKeepDistanceNextCamera = true; +} + +void invalidateKeepDistanceNextCameraIfNoCollide(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidKeepDistanceNextCameraIfNoCollide = true; +} + +void invalidatePreCameraEndAfterInterpole(al::CameraPoser* cameraPoser) { + cameraPoser->getPoserFag()->isInvalidPreCameraEndAfterInterpole = true; +} + +bool isInvalidPreCameraEndAfterInterpole(const al::CameraPoser* cameraPoser) { + return cameraPoser->getPoserFag()->isInvalidPreCameraEndAfterInterpole; +} + +bool isSceneCameraFirstCalc(const al::CameraPoser* cameraPoser) { + return cameraPoser->getViewInfo()->isFirstCalc(); +} + +bool isActiveInterpole(const al::CameraPoser* cameraPoser) { + return cameraPoser->getViewInfo()->isActiveInterpole(); +} + +bool isInvalidEndEntranceCamera(const al::CameraPoser* cameraPoser) { + return cameraPoser->getFlagCtrl()->isInvalidEndEntranceCamera; +} + +bool isPause(const al::CameraPoser* cameraPoser) { + return false; +} + +bool checkFirstCameraCollisionArrow(sead::Vector3f* outHitPos, sead::Vector3f* outNormal, + const al::IUseCollision* collision, const sead::Vector3f& pos, + const sead::Vector3f& dir) { + CameraCollisionHitResult result; + if (!checkFirstCameraCollisionArrow(&result, collision, pos, dir)) + return false; + + if (outHitPos) + outHitPos->set(result.hitPos); + if (outNormal) + outNormal->set(result.normal); + + return true; +} + +bool checkFirstCameraCollisionArrow(CameraCollisionHitResult* outResult, + const al::IUseCollision* collision, const sead::Vector3f& pos, + const sead::Vector3f& dir) { + const al::ArrowHitInfo* hitInfo = nullptr; + + if (!alCollisionUtil::getFirstPolyOnArrow(collision, &hitInfo, pos, dir, &sPartsFiler, + &sTriangleFilter)) { + return false; + } + + outResult->hitPos.set(hitInfo->hitInfo->collisionHitPos); + outResult->normal.set(hitInfo->hitInfo->triangle.getNormal(0)); + + s32 type = 2; + if (hitInfo->hitInfo->isCollisionAtFace()) + type = 0; + else if (hitInfo->hitInfo->isCollisionAtEdge()) + type = 1; + + outResult->type = type; + + return true; +} + +bool checkFirstCameraCollisionArrowOnlyCeiling(sead::Vector3f* outHitPos, sead::Vector3f* outNormal, + const al::IUseCollision* collision, + const sead::Vector3f& pos, + const sead::Vector3f& dir) { + al::Triangle triangle; + sead::Vector3f hitPos = {0.0f, 0.0f, 0.0f}; + if (!alCollisionUtil::getFirstPolyOnArrow(collision, &hitPos, &triangle, pos, dir, nullptr, + &sCeilFilter)) { + return false; + } + + if (outHitPos) + outHitPos->set(hitPos); + + if (outNormal) + outNormal->set(triangle.getNormal(0)); + return true; +} + +f32 calcZoneRotateAngleH(f32 angle, const al::CameraPoser* cameraPoser) { + return calcZoneRotateAngleH(angle, cameraPoser->getViewMtx()); +} + +f32 calcZoneRotateAngleH(f32 angle, const sead::Matrix34f& mtx) { + f32 sin = sead::Mathf::sin(sead::Mathf::deg2rad(angle)); + f32 cos = sead::Mathf::cos(sead::Mathf::deg2rad(angle)); + + f32 rotateAngle = + sead::Mathf::atan2(sin * mtx.m[0][0] + 0.0f * mtx.m[0][1] + cos * mtx.m[0][2], + sin * mtx.m[2][0] + 0.0f * mtx.m[2][1] + cos * mtx.m[2][2]); + + return sead::Mathf::rad2deg(rotateAngle); +} + +f32 calcZoneInvRotateAngleH(f32 angle, const sead::Matrix34f& mtx) { + f32 sin = sead::Mathf::sin(sead::Mathf::deg2rad(angle)); + f32 cos = sead::Mathf::cos(sead::Mathf::deg2rad(angle)); + + f32 rotateAngle = + sead::Mathf::atan2(sin * mtx.m[0][0] + 0.0f * mtx.m[1][0] + cos * mtx.m[2][0], + sin * mtx.m[0][2] + 0.0f * mtx.m[1][2] + cos * mtx.m[2][2]); + + return sead::Mathf::rad2deg(rotateAngle); +} + +void multVecZone(sead::Vector3f* outVec, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser) { + outVec->setMul(cameraPoser->getViewMtx(), vec); +} + +void multVecInvZone(sead::Vector3f* outVec, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser) { + sead::Matrix34f mtx = sead::Matrix34f::ident; + mtx.setInverse(cameraPoser->getViewMtx()); + outVec->setMul(mtx, vec); +} + +void rotateVecZone(sead::Vector3f* outVec, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser) { + outVec->setRotated(cameraPoser->getViewMtx(), vec); +} + +bool makeCameraKeepInFrameV(sead::LookAtCamera* camera, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser, f32 a, f32 b) { + sead::Vector3f offset = {0.0f, 0.0f, 0.0f}; + if (calcOffsetCameraKeepInFrameV(&offset, camera, vec, cameraPoser, a, b)) { + camera->setAt(camera->getAt() + offset); + camera->setPos(camera->getPos() + offset); + return true; + } + return false; +} + +void initCameraRail(al::CameraPoser* cameraPoser, const al::PlacementInfo& info, const char* name) { + al::PlacementInfo placementInfo; + al::tryGetLinksInfo(&placementInfo, info, name); + cameraPoser->initRail(placementInfo); +} + +bool tryGetCameraRailArg(f32* outArg, const al::PlacementInfo& info, const char* argName, + const char* name) { + al::PlacementInfo placementInfo; + if (!al::tryGetLinksInfo(&placementInfo, info, name)) + return false; + + return al::tryGetArg(outArg, placementInfo, argName); +} + +const char* getCameraRailPointObjId(const al::CameraPoser* cameraPoser, s32 index) { + al::PlacementInfo* railPointInfo = al::getRailPointInfo(cameraPoser, index); + + al::PlacementId placementId; + placementId.init(*railPointInfo); + return placementId.getId(); +} + +al::CameraLimitRailKeeper* tryFindNearestLimitRailKeeper(const al::CameraPoser* cameraPoser, + const sead::Vector3f& pos) { + f32 minDistance = -1.0f; + al::CameraLimitRailKeeper* nearestRailKeeper = nullptr; + + for (s32 i = 0; i < cameraPoser->getSceneInfo()->railHolderNum; i++) { + for (s32 j = 0; j < cameraPoser->getSceneInfo()->railHolders[i]->getRailCount(); j++) { + al::CameraLimitRailKeeper* railKeeper = + cameraPoser->getSceneInfo()->railHolders[i]->getRail(j); + + sead::Vector3f nearestPos = {0.0f, 0.0f, 0.0f}; + railKeeper->calcNearestRailPos(&nearestPos, pos); + f32 distance = (nearestPos - pos).length(); + + if (railKeeper->getActivateDistance() < distance) + continue; + + if (minDistance < 0.0f || distance < minDistance) { + minDistance = distance; + nearestRailKeeper = railKeeper; + } + } + } + + return nearestRailKeeper; +} + +void calcCameraRotateStick(sead::Vector2f* outStick, const al::CameraPoser* cameraPoser) { + getCameraInput(cameraPoser)->calcInputStick(outStick); + + if (cameraPoser->getFlagCtrl()->isCameraReverseInputH) + outStick->x = -outStick->x; + if (cameraPoser->getFlagCtrl()->isCameraReverseInputV) + outStick->y = -outStick->y; +} + +f32 calcCameraRotateStickH(const al::CameraPoser* cameraPoser) { + sead::Vector2f stick = {0.0f, 0.0f}; + calcCameraRotateStick(&stick, cameraPoser); + return stick.x; +} + +f32 calcCameraRotateStickV(const al::CameraPoser* cameraPoser) { + sead::Vector2f stick = {0.0f, 0.0f}; + calcCameraRotateStick(&stick, cameraPoser); + return stick.y; +} + +f32 calcCameraRotateStickPower(const al::CameraPoser* cameraPoser) { + sead::Vector2f stick = {0.0f, 0.0f}; + calcCameraRotateStick(&stick, cameraPoser); + return stick.length(); +} + +s32 getStickSensitivityLevel(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->getStickSensitivityLevel(); +} + +f32 getStickSensitivityScale(const al::CameraPoser* cameraPoser) { + switch (getStickSensitivityLevel(cameraPoser)) { + case -2: + return 0.44f; + case -1: + return 0.72f; + case 0: + return 1.6f; + case 1: + return 1.27f; + case 2: + return 1.55f; + default: + return 1.0f; + } +} + +bool isValidGyro(const al::CameraPoser* cameraPoser) { + return !cameraPoser->getFlagCtrl()->isInvalidCameraGyro; +} + +s32 getGyroSensitivityLevel(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->getGyroSensitivityLevel(); +} + +f32 getGyroSensitivityScale(const al::CameraPoser* cameraPoser) { + switch (getGyroSensitivityLevel(cameraPoser)) { + case -1: + return 0.625f; + case 0: + return 1.0f; + case 1: + return 1.6f; + default: + return 1.0f; + } +} + +bool isTriggerCameraResetRotate(const al::CameraPoser* cameraPoser) { + return !isSnapShotMode(cameraPoser) && getCameraInput(cameraPoser)->isTriggerReset(); +} + +bool isHoldCameraZoom(const al::CameraPoser* cameraPoser) { + return getCameraInput(cameraPoser)->isHoldZoom(); +} + +bool isHoldCameraSnapShotZoomIn(const al::CameraPoser* cameraPoser) { + return getCameraInput(cameraPoser)->isHoldSnapShotZoomIn(); +} + +bool isHoldCameraSnapShotZoomOut(const al::CameraPoser* cameraPoser) { + return getCameraInput(cameraPoser)->isHoldSnapShotZoomOut(); +} + +bool isHoldCameraSnapShotRollLeft(const al::CameraPoser* cameraPoser) { + return getCameraInput(cameraPoser)->isHoldSnapShotRollLeft(); +} + +bool isHoldCameraSnapShotRollRight(const al::CameraPoser* cameraPoser) { + return getCameraInput(cameraPoser)->isHoldSnapShotRollRight(); +} + +bool tryCalcCameraSnapShotMoveStick(sead::Vector2f* outStick, const al::CameraPoser* cameraPoser) { + return getCameraInput(cameraPoser)->tryCalcSnapShotMoveStick(outStick); +} + +bool isPlayerTypeFlyer(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->isPlayerTypeFlyer(); +} + +bool isPlayerTypeHighSpeedMove(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->isPlayerTypeHighSpeedMove(); +} + +bool isPlayerTypeHighJump(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->isPlayerTypeHighJump(); +} + +bool isPlayerTypeNotTouchGround(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->isPlayerTypeNotTouchGround(); +} + +bool isOnRideObj(const al::CameraPoser* cameraPoser) { + return cameraPoser->getSceneInfo()->requestParamHolder->isOnRideObj(); +} + } // namespace alCameraPoserFunction diff --git a/lib/al/Library/Camera/CameraPoserFunction.h b/lib/al/Library/Camera/CameraPoserFunction.h index c5211ac595..20b25cd2b6 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.h +++ b/lib/al/Library/Camera/CameraPoserFunction.h @@ -11,22 +11,28 @@ class LookAtCamera; namespace al { class CameraPoser; +class CameraLimitRailKeeper; class Projection; struct CameraStartInfo; struct CameraObjectRequestInfo; class IUseCollision; class PlacementInfo; class Projection; + } // namespace al namespace alCameraPoserFunction { -class CameraCollisionHitResult; +struct CameraCollisionHitResult { + sead::Vector3f hitPos = {0.0f, 0.0f, 0.0f}; + sead::Vector3f normal = {0.0f, 0.0f, 0.0f}; + s32 type = 2; +}; s32 getViewIndex(const al::CameraPoser* cameraPoser); const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser); const sead::Projection& getProjectionSead(const al::CameraPoser* cameraPoser); const al::Projection& getProjection(const al::CameraPoser* cameraPoser); -void getProjectionMtx(const al::CameraPoser* cameraPoser); +const sead::Matrix44f& getProjectionMtx(const al::CameraPoser* cameraPoser); f32 getNear(const al::CameraPoser* cameraPoser); f32 getFar(const al::CameraPoser* cameraPoser); f32 getAspect(const al::CameraPoser* cameraPoser); @@ -59,37 +65,37 @@ f32 getAreaAngleV(const al::CameraStartInfo& cameraStartInfo); bool isExistNextPoseByPreCamera(const al::CameraStartInfo& cameraStartInfo); f32 getNextAngleHByPreCamera(const al::CameraStartInfo& cameraStartInfo); f32 getNextAngleVByPreCamera(const al::CameraStartInfo& cameraStartInfo); -void calcCameraPose(sead::Quatf* out, const al::CameraPoser* cameraPoser); -void calcLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -bool calcCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -bool calcLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcSideDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcPreCameraDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcPreCameraDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcPreLookDir(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcPreLookDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcCameraPose(sead::Quatf* outPose, const al::CameraPoser* cameraPoser); +void calcLookDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcCameraDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +bool calcCameraDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser); +bool calcLookDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser); +void calcSideDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcPreCameraDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcPreCameraDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser); +void calcPreLookDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcPreLookDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser); f32 calcPreCameraAngleH(const al::CameraPoser* cameraPoser); f32 calcPreCameraAngleV(const al::CameraPoser* cameraPoser); void setLookAtPosToTarget(al::CameraPoser* cameraPoser); -void calcTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser); void setLookAtPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset); void setCameraPosToTarget(al::CameraPoser* cameraPoser); void setCameraPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset); -void calcTargetTransWithOffset(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcTargetVelocity(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcTargetVelocityH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcTargetUp(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetTransWithOffset(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser); +void calcTargetVelocity(sead::Vector3f* outVelocity, const al::CameraPoser* cameraPoser); +void calcTargetVelocityH(sead::Vector3f* outVelocityH, const al::CameraPoser* cameraPoser); +void calcTargetUp(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser); -void calcTargetPose(sead::Quatf* out, const al::CameraPoser* cameraPoser); -void calcTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcTargetSide(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcTargetGravity(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcTargetPose(sead::Quatf* outPose, const al::CameraPoser* cameraPoser); +void calcTargetFront(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcTargetSide(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcTargetGravity(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); f32 calcTargetSpeedH(const al::CameraPoser* cameraPoser); f32 calcTargetJumpSpeed(const al::CameraPoser* cameraPoser); f32 calcTargetFallSpeed(const al::CameraPoser* cameraPoser); bool isChangeTarget(const al::CameraPoser* cameraPoser); -bool tryGetTargetRequestDistance(f32* out, const al::CameraPoser* cameraPoser); +bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* cameraPoser); f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser); f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser); bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser); @@ -97,23 +103,25 @@ const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser* cameraPo const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser* cameraPoser); bool isExistSlopeCollisionUnderTarget(const al::CameraPoser* cameraPoser); bool isExistWallCollisionUnderTarget(const al::CameraPoser* cameraPoser); -bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* outDirH, + const al::CameraPoser* cameraPoser); f32 getSlopeCollisionUpSpeed(const al::CameraPoser* cameraPoser); f32 getSlopeCollisionDownSpeed(const al::CameraPoser* cameraPoser); bool isExistSubTarget(const al::CameraPoser* cameraPoser); bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser); -void calcSubTargetBack(sead::Vector3f* out, const al::CameraPoser* cameraPoser); -void calcSubTargetTrans(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcSubTargetBack(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); +void calcSubTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser); bool isChangeSubTarget(const al::CameraPoser* cameraPoser); -void calcSubTargetFront(sead::Vector3f* out, const al::CameraPoser* cameraPoser); +void calcSubTargetFront(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser); f32 getSubTargetRequestDistance(const al::CameraPoser* cameraPoser); f32 getSubTargetTurnSpeedRate1(const al::CameraPoser* cameraPoser); f32 getSubTargetTurnSpeedRate2(const al::CameraPoser* cameraPoser); s32 getSubTargetTurnRestartStep(const al::CameraPoser* cameraPoser); -bool tryCalcSubTargetTurnBrakeDistanceRate(f32* out, const al::CameraPoser* cameraPoser); +bool tryCalcSubTargetTurnBrakeDistanceRate(f32* outDistanceRate, + const al::CameraPoser* cameraPoser); bool isValidSubTargetTurnV(const al::CameraPoser* cameraPoser); bool isValidSubTargetResetAfterTurnV(const al::CameraPoser* cameraPoser); -void clampAngleSubTargetTurnRangeV(f32* out, const al::CameraPoser* cameraPoser); +void clampAngleSubTargetTurnRangeV(f32* outTurnRangeV, const al::CameraPoser* cameraPoser); void initCameraVerticalAbsorber(al::CameraPoser* cameraPoser); void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser* cameraPoser); f32 getCameraVerticalAbsorbPosUp(const al::CameraPoser* cameraPoser); @@ -135,21 +143,21 @@ void initCameraAngleCtrlWithRelativeH(al::CameraPoser* cameraPoser); void initCameraDefaultAngleRangeV(al::CameraPoser* cameraPoser, f32 min, f32 max); void setCameraStartAngleV(al::CameraPoser* cameraPoser, f32 angle); void setCameraAngleV(al::CameraPoser* cameraPoser, f32 angle); -void getCameraAngleH(const al::CameraPoser* cameraPoser); -void getCameraAngleV(const al::CameraPoser* cameraPoser); +f32 getCameraAngleH(const al::CameraPoser* cameraPoser); +f32 getCameraAngleV(const al::CameraPoser* cameraPoser); void initAngleSwing(al::CameraPoser* cameraPoser); bool isValidAngleSwing(const al::CameraPoser* cameraPoser); void initCameraOffsetCtrlPreset(al::CameraPoser* cameraPoser); -void getOffset(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getOffset(const al::CameraPoser* cameraPoser); void initGyroCameraCtrl(al::CameraPoser* cameraPoser); void resetGyro(al::CameraPoser* cameraPoser); -void calcCameraGyroPose(const al::CameraPoser* cameraPoser, sead::Vector3f*, sead::Vector3f*, - sead::Vector3f*); -void getGyroFront(al::CameraPoser* cameraPoser); -void getGyroAngleV(al::CameraPoser* cameraPoser); -void getGyroAngleH(al::CameraPoser* cameraPoser); -void setGyroLimitAngleV(al::CameraPoser* cameraPoser, f32, f32); -void setGyroSensitivity(al::CameraPoser* cameraPoser, f32, f32); +void calcCameraGyroPose(const al::CameraPoser* cameraPoser, sead::Vector3f* gyroPoseX, + sead::Vector3f* gyroPoseY, sead::Vector3f* gyroPoseZ); +const sead::Vector3f& getGyroFront(al::CameraPoser* cameraPoser); +f32 getGyroAngleV(al::CameraPoser* cameraPoser); +f32 getGyroAngleH(al::CameraPoser* cameraPoser); +void setGyroLimitAngleV(al::CameraPoser* cameraPoser, f32 min, f32 max); +void setGyroSensitivity(al::CameraPoser* cameraPoser, f32 min, f32 max); void reduceGyroSencitivity(al::CameraPoser* cameraPoser); void stopUpdateGyro(al::CameraPoser* cameraPoser); void restartUpdateGyro(al::CameraPoser* cameraPoser); @@ -170,24 +178,24 @@ void validateSnapShotCameraLookAtOffset(al::CameraPoser* cameraPoser); void validateSnapShotCameraZoomFovy(al::CameraPoser* cameraPoser); void validateSnapShotCameraRoll(al::CameraPoser* cameraPoser); void updateSnapShotCameraCtrl(al::CameraPoser* cameraPoser); -void startResetSnapShotCameraCtrl(al::CameraPoser* cameraPoser, s32); -void setSnapShotMaxZoomOutFovyDegree(al::CameraPoser* cameraPoser, f32); -void getSnapShotRollDegree(const al::CameraPoser* cameraPoser); -void getSnapShotLookAtOffset(const al::CameraPoser* cameraPoser); +void startResetSnapShotCameraCtrl(al::CameraPoser* cameraPoser, s32 value); +void setSnapShotMaxZoomOutFovyDegree(al::CameraPoser* cameraPoser, f32 value); +f32 getSnapShotRollDegree(const al::CameraPoser* cameraPoser); +const sead::Vector3f& getSnapShotLookAtOffset(const al::CameraPoser* cameraPoser); bool isOffVerticalAbsorb(const al::CameraPoser* cameraPoser); void onVerticalAbsorb(al::CameraPoser* cameraPoser); void offVerticalAbsorb(al::CameraPoser* cameraPoser); void invalidateCameraBlur(al::CameraPoser* cameraPoser); -bool isRequestStopVerticalAbsorb(const al::CameraObjectRequestInfo&); -bool isRequestResetPosition(const al::CameraObjectRequestInfo&); -bool isRequestResetAngleV(const al::CameraObjectRequestInfo&); -bool isRequestDownToDefaultAngleBySpeed(const al::CameraObjectRequestInfo&); -bool isRequestUpToTargetAngleBySpeed(const al::CameraObjectRequestInfo&); -void getRequestTargetAngleV(const al::CameraObjectRequestInfo&); -void getRequestAngleSpeed(const al::CameraObjectRequestInfo&); -bool isRequestMoveDownAngleV(const al::CameraObjectRequestInfo&); -bool isRequestSetAngleV(const al::CameraObjectRequestInfo&); -void getRequestAngleV(const al::CameraObjectRequestInfo&); +bool isRequestStopVerticalAbsorb(const al::CameraObjectRequestInfo& requestInfo); +bool isRequestResetPosition(const al::CameraObjectRequestInfo& requestInfo); +bool isRequestResetAngleV(const al::CameraObjectRequestInfo& requestInfo); +bool isRequestDownToDefaultAngleBySpeed(const al::CameraObjectRequestInfo& requestInfo); +bool isRequestUpToTargetAngleBySpeed(const al::CameraObjectRequestInfo& requestInfo); +f32 getRequestTargetAngleV(const al::CameraObjectRequestInfo& requestInfo); +f32 getRequestAngleSpeed(const al::CameraObjectRequestInfo& requestInfo); +bool isRequestMoveDownAngleV(const al::CameraObjectRequestInfo& requestInfo); +bool isRequestSetAngleV(const al::CameraObjectRequestInfo& requestInfo); +f32 getRequestAngleV(const al::CameraObjectRequestInfo& requestInfo); bool isInvalidCollider(const al::CameraPoser* cameraPoser); void validateCollider(al::CameraPoser* cameraPoser); void invalidateCollider(al::CameraPoser* cameraPoser); @@ -201,30 +209,40 @@ bool isSceneCameraFirstCalc(const al::CameraPoser* cameraPoser); bool isActiveInterpole(const al::CameraPoser* cameraPoser); bool isInvalidEndEntranceCamera(const al::CameraPoser* cameraPoser); bool isPause(const al::CameraPoser* cameraPoser); -bool checkFirstCameraCollisionArrow(sead::Vector3f*, sead::Vector3f*, const al::IUseCollision*, - const sead::Vector3f&, const sead::Vector3f&); -bool checkFirstCameraCollisionArrow(CameraCollisionHitResult*, const al::IUseCollision*, - const sead::Vector3f&, const sead::Vector3f&); -bool checkFirstCameraCollisionArrowOnlyCeiling(sead::Vector3f*, sead::Vector3f*, - const al::IUseCollision*, const sead::Vector3f&, - const sead::Vector3f&); -void checkCameraCollisionMoveSphere(sead::Vector3f*, const al::IUseCollision*, - const sead::Vector3f&, const sead::Vector3f&, f32); -f32 calcZoneRotateAngleH(f32, const al::CameraPoser* cameraPoser); -f32 calcZoneRotateAngleH(f32, const sead::Matrix34f&); -f32 calcZoneInvRotateAngleH(f32, const sead::Matrix34f&); -void multVecZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser* cameraPoser); -void multVecInvZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser* cameraPoser); -void rotateVecZone(sead::Vector3f*, const sead::Vector3f&, const al::CameraPoser* cameraPoser); -void calcOffsetCameraKeepInFrameV(sead::Vector3f*, sead::LookAtCamera*, const sead::Vector3f&, +bool checkFirstCameraCollisionArrow(sead::Vector3f* outHitPos, sead::Vector3f* outNormal, + const al::IUseCollision* collision, const sead::Vector3f& pos, + const sead::Vector3f& dir); +bool checkFirstCameraCollisionArrow(CameraCollisionHitResult* outResult, + const al::IUseCollision* collision, const sead::Vector3f& pos, + const sead::Vector3f& dir); +bool checkFirstCameraCollisionArrowOnlyCeiling(sead::Vector3f* outHitPos, sead::Vector3f* outNormal, + const al::IUseCollision* collision, + const sead::Vector3f& pos, + const sead::Vector3f& dir); +void checkCameraCollisionMoveSphere(sead::Vector3f* outHitPos, const al::IUseCollision* collision, + const sead::Vector3f& pos, const sead::Vector3f& dir, + f32 radius); +f32 calcZoneRotateAngleH(f32 angle, const al::CameraPoser* cameraPoser); +f32 calcZoneRotateAngleH(f32 angle, const sead::Matrix34f& mtx); +f32 calcZoneInvRotateAngleH(f32 angle, const sead::Matrix34f& mtx); +void multVecZone(sead::Vector3f* outVec, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser); +void multVecInvZone(sead::Vector3f* outVec, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser); +void rotateVecZone(sead::Vector3f* outVec, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser); +bool calcOffsetCameraKeepInFrameV(sead::Vector3f*, sead::LookAtCamera*, const sead::Vector3f&, const al::CameraPoser* cameraPoser, f32, f32); -void makeCameraKeepInFrameV(sead::LookAtCamera*, const sead::Vector3f&, - const al::CameraPoser* cameraPoser, f32, f32); -void initCameraRail(al::CameraPoser* cameraPoser, const al::PlacementInfo&, const char*); -bool tryGetCameraRailArg(f32*, const al::PlacementInfo&, const char*, const char*); -// void getCameraRailPointObjId(al::CameraPoser const*, s32); -bool tryFindNearestLimitRailKeeper(const al::CameraPoser* cameraPoser, const sead::Vector3f&); -void calcCameraRotateStick(sead::Vector2f*, const al::CameraPoser* cameraPoser); +// TODO: Find proper parameter names for a and b +bool makeCameraKeepInFrameV(sead::LookAtCamera* camera, const sead::Vector3f& vec, + const al::CameraPoser* cameraPoser, f32 a, f32 b); +void initCameraRail(al::CameraPoser* cameraPoser, const al::PlacementInfo& info, const char* name); +bool tryGetCameraRailArg(f32* outArg, const al::PlacementInfo& info, const char* argName, + const char* name); +const char* getCameraRailPointObjId(const al::CameraPoser* cameraPoser, s32 index); +al::CameraLimitRailKeeper* tryFindNearestLimitRailKeeper(const al::CameraPoser* cameraPoser, + const sead::Vector3f& pos); +void calcCameraRotateStick(sead::Vector2f* outStick, const al::CameraPoser* cameraPoser); f32 calcCameraRotateStickH(const al::CameraPoser* cameraPoser); f32 calcCameraRotateStickV(const al::CameraPoser* cameraPoser); f32 calcCameraRotateStickPower(const al::CameraPoser* cameraPoser); @@ -239,7 +257,7 @@ bool isHoldCameraSnapShotZoomIn(const al::CameraPoser* cameraPoser); bool isHoldCameraSnapShotZoomOut(const al::CameraPoser* cameraPoser); bool isHoldCameraSnapShotRollLeft(const al::CameraPoser* cameraPoser); bool isHoldCameraSnapShotRollRight(const al::CameraPoser* cameraPoser); -bool tryCalcCameraSnapShotMoveStick(sead::Vector2f*, const al::CameraPoser* cameraPoser); +bool tryCalcCameraSnapShotMoveStick(sead::Vector2f* outStick, const al::CameraPoser* cameraPoser); bool isPlayerTypeFlyer(const al::CameraPoser* cameraPoser); bool isPlayerTypeHighSpeedMove(const al::CameraPoser* cameraPoser); bool isPlayerTypeHighJump(const al::CameraPoser* cameraPoser); diff --git a/lib/al/Library/Camera/CameraPoserSceneInfo.h b/lib/al/Library/Camera/CameraPoserSceneInfo.h index 07df5b9e81..54da8c6153 100644 --- a/lib/al/Library/Camera/CameraPoserSceneInfo.h +++ b/lib/al/Library/Camera/CameraPoserSceneInfo.h @@ -33,4 +33,5 @@ struct CameraPoserSceneInfo { s32 railHolderNum = 0; }; +static_assert(sizeof(CameraPoserSceneInfo) == 0x60); } // namespace al diff --git a/lib/al/Library/Camera/CameraRequestParamHolder.h b/lib/al/Library/Camera/CameraRequestParamHolder.h index 1dc752e595..8fdfcae38c 100644 --- a/lib/al/Library/Camera/CameraRequestParamHolder.h +++ b/lib/al/Library/Camera/CameraRequestParamHolder.h @@ -39,6 +39,8 @@ class CameraRequestParamHolder { f32* get_58() const { return _58; } + bool isOnRideObj() const { return mRideObjCamera && mIsCurrRideObj; } + private: s32 mStickSensitivityLevel = 0; s32 mGyroSensitivityLevel = 0; @@ -61,4 +63,5 @@ class CameraRequestParamHolder { f32* _60 = nullptr; }; +static_assert(sizeof(CameraRequestParamHolder) == 0x68); } // namespace al diff --git a/lib/al/Library/Camera/CameraTargetHolder.cpp b/lib/al/Library/Camera/CameraTargetHolder.cpp index 32ed5b71a4..a4f8a0a683 100644 --- a/lib/al/Library/Camera/CameraTargetHolder.cpp +++ b/lib/al/Library/Camera/CameraTargetHolder.cpp @@ -64,8 +64,8 @@ void CameraTargetHolder::update() { else if (!mPlacementSubTargetArray.isEmpty()) topSubTarget = mPlacementSubTargetArray.front(); - mHasTopSubTargetChanged = mTopSubTarget != topSubTarget; - mTopSubTarget = topSubTarget; + mTopSubTargetInfo.hasTargetChanged = mTopSubTargetInfo.target != topSubTarget; + mTopSubTargetInfo.target = topSubTarget; if (topSubTarget) topSubTarget->update(); } @@ -102,7 +102,7 @@ bool CameraTargetHolder::isChangeViewTarget(s32 index) const { } CameraSubTargetBase* CameraTargetHolder::getTopSubTarget() const { - return mTopSubTarget; + return mTopSubTargetInfo.target; } // NON_MATCHING: Depends on removeSubTarget diff --git a/lib/al/Library/Camera/CameraTargetHolder.h b/lib/al/Library/Camera/CameraTargetHolder.h index 52cf1da043..b6ccf87762 100644 --- a/lib/al/Library/Camera/CameraTargetHolder.h +++ b/lib/al/Library/Camera/CameraTargetHolder.h @@ -15,6 +15,12 @@ struct ViewTargetInfo { s8 hasTargetChanged = false; }; +struct ViewSubTargetInfo { + CameraSubTargetBase* target = nullptr; + // Note: s8 is used instead of bool to match isChangeSubTarget + s8 hasTargetChanged = false; +}; + static_assert(sizeof(ViewTargetInfo) == 0x10); class CameraTargetHolder { @@ -34,19 +40,14 @@ class CameraTargetHolder { void addPlacementSubTarget(CameraSubTargetBase* subTarget); void removePlacementSubTarget(CameraSubTargetBase* subTarget); - bool isChangeViewTarget(u32 index) const; - - s8 hasTopSubTargetChanged() const { return mHasTopSubTargetChanged; } - - CameraSubTargetBase* getTopSubTargetInline() const { return mTopSubTarget; } + const ViewSubTargetInfo& getTopSubTargetInfo() const { return mTopSubTargetInfo; } private: s32 mViewTargetSize = 0; CameraTargetBase** mViewTargetArray = nullptr; ViewTargetInfo* mViewTargetInfo = nullptr; sead::PtrArray mTargetArray; - CameraSubTargetBase* mTopSubTarget = nullptr; - s8 mHasTopSubTargetChanged = false; // What? This is required to match? + ViewSubTargetInfo mTopSubTargetInfo; sead::PtrArray mSubTargetArray; sead::PtrArray mPlacementSubTargetArray; }; diff --git a/lib/al/Library/Camera/CameraTriangleFilter.h b/lib/al/Library/Camera/CameraTriangleFilter.h new file mode 100644 index 0000000000..37156aa938 --- /dev/null +++ b/lib/al/Library/Camera/CameraTriangleFilter.h @@ -0,0 +1,28 @@ +#pragma once + +#include "Library/Collision/PartsInterpolator.h" + +namespace al { + +class CameraTriangleFilter : public TriangleFilterBase { +public: + CameraTriangleFilter() {} + + bool isInvalidTriangle(const Triangle& triangle) const override; +}; + +class CameraTriangleFilterOnlyCeiling : public CameraTriangleFilter { +public: + CameraTriangleFilterOnlyCeiling() {} + + bool isInvalidTriangle(const Triangle& triangle) const override; +}; + +class SubjectiveCameraTriangleFilter : public TriangleFilterBase { +public: + SubjectiveCameraTriangleFilter() {} + + bool isInvalidTriangle(const Triangle& triangle) const override; +}; + +} // namespace al diff --git a/lib/al/Library/Camera/CameraUtil.h b/lib/al/Library/Camera/CameraUtil.h index 2dad623ab5..45ecccb781 100644 --- a/lib/al/Library/Camera/CameraUtil.h +++ b/lib/al/Library/Camera/CameraUtil.h @@ -11,7 +11,7 @@ class ICameraInput; struct CameraFlagCtrl; class IUseCamera; class CameraSubTargetBase; -class CameraSubTargetTurnParam; +struct CameraSubTargetTurnParam; class SceneCameraInfo; class PlacementId; class Resource; diff --git a/lib/al/Library/Camera/CameraViewCtrlGyro.h b/lib/al/Library/Camera/CameraViewCtrlGyro.h index c594825fcf..2191a17ee3 100644 --- a/lib/al/Library/Camera/CameraViewCtrlGyro.h +++ b/lib/al/Library/Camera/CameraViewCtrlGyro.h @@ -17,16 +17,32 @@ class GyroCameraCtrl { void setSensitivityScale(f32 sensitivityScale) { mSensitivityScale = sensitivityScale; } + const sead::Vector3f& getFront() const { return mFront; } + + f32 getAngleV() const { return mAngleV; } + + f32 getAngleH() const { return mAngleH; } + + void setLimitAngleV(f32 min, f32 max) { + mMinAngleV = min; + mMaxAngleV = max; + } + + void setSensitivity(f32 min, f32 max) { + mMinSensitivity = min; + mMaxSensitivity = max; + } + private: sead::Matrix34f _0; sead::Vector3f _30; sead::Vector3f _3c; sead::Vector3f _48; - sead::Vector3f _54; + sead::Vector3f mFront; sead::Vector3f _60; sead::Vector3f _6c; - f32 _78; - f32 _7c; + f32 mAngleV; + f32 mAngleH; f32 _80; f32 _84; f32 _88; @@ -39,10 +55,10 @@ class GyroCameraCtrl { f32 _a4; f32 mSensitivityScale; bool mIsValidGyro; - f32 _b0; - f32 _b4; - f32 _b8; - f32 _bc; + f32 mMaxSensitivity; + f32 mMinSensitivity; + f32 mMinAngleV; + f32 mMaxAngleV; f32 _c0; f32 _c4; }; diff --git a/lib/al/Library/Camera/CameraViewInfo.h b/lib/al/Library/Camera/CameraViewInfo.h index f1af388a1d..8e33947aa2 100644 --- a/lib/al/Library/Camera/CameraViewInfo.h +++ b/lib/al/Library/Camera/CameraViewInfo.h @@ -25,6 +25,10 @@ class CameraViewInfo { bool isValid() const { return mIsValid; } + bool isFirstCalc() const { return mIsFirstCalc; } + + bool isActiveInterpole() const { return mIsActiveInterpole; } + const sead::LookAtCamera& getLookAtCam() const { return mLookAtCam; } const Projection& getProjection() const { return mProjection; } @@ -32,8 +36,8 @@ class CameraViewInfo { private: s32 mIndex; bool mIsValid = true; - bool mIsActiveInterpole = true; - bool _6 = false; + bool mIsFirstCalc = true; + bool mIsActiveInterpole = false; const sead::LookAtCamera& mLookAtCam; const Projection& mProjection; const CameraViewFlag& mViewFlag; diff --git a/lib/al/Library/Camera/SnapShotCameraCtrl.h b/lib/al/Library/Camera/SnapShotCameraCtrl.h index 6abf8d1677..ad6604f99c 100644 --- a/lib/al/Library/Camera/SnapShotCameraCtrl.h +++ b/lib/al/Library/Camera/SnapShotCameraCtrl.h @@ -32,6 +32,22 @@ class SnapShotCameraCtrl : public NerveExecutor, public IUseAudioKeeper { f32 getFovyDegree() const { return mFovyDegree; }; + AudioKeeper* getAudioKeeper() const override; + + void setIsValidLookAtOffset(bool isValid) { mIsValidLookAtOffset = isValid; }; + + void setIsValidZoomFovy(bool isValid) { mIsValidZoomFovy = isValid; }; + + void setIsValidRoll(bool isValid) { mIsValidRoll = isValid; }; + + void set_68(bool isValid) { _68 = isValid; }; + + void setMaxZoomOutFovyDegree(f32 value) { mMaxZoomOutFovyDegree = value; }; + + f32 getRollDegree() const { return mRollDegree; }; + + const sead::Vector3f& getLookAtOffset() const { return mLookAtOffset; }; + private: SnapShotCameraSceneInfo* mCameraSceneInfo; CameraParam* mParam; @@ -40,13 +56,15 @@ class SnapShotCameraCtrl : public NerveExecutor, public IUseAudioKeeper { sead::Vector3f unk1; bool mIsValidZoomFovy; f32 mFovyDegree; - f32 unk2; - f32 unk3; + f32 _4c; + f32 _50; f32 mMaxZoomOutFovyDegree; bool mIsValidRoll; f32 mRollDegree; f32 mRollTarget; - u32 unk4; - bool unk5; + u32 _64; + bool _68; }; + +static_assert(sizeof(SnapShotCameraCtrl) == 0x70); } // namespace al diff --git a/lib/al/Library/Collision/KCollisionServer.h b/lib/al/Library/Collision/KCollisionServer.h index 4cf12bdea8..a7111c4e83 100644 --- a/lib/al/Library/Collision/KCollisionServer.h +++ b/lib/al/Library/Collision/KCollisionServer.h @@ -193,14 +193,14 @@ class SpherePoseInterpolator { class CollisionPartsFilterBase { public: - virtual bool isInvalidParts(CollisionParts* collisionParts) = 0; + virtual bool isInvalidParts(const CollisionParts& collisionParts) const = 0; }; class CollisionPartsFilterActor : public CollisionPartsFilterBase { public: CollisionPartsFilterActor(const LiveActor* actor) : mActor(actor) {} - bool isInvalidParts(CollisionParts* collisionParts) override; + bool isInvalidParts(const CollisionParts& collisionParts) const override; private: const LiveActor* mActor; @@ -211,7 +211,7 @@ class CollisionPartsFilterSubActor : public CollisionPartsFilterBase { public: CollisionPartsFilterSubActor(const LiveActor* actor) : mActor(actor) {} - bool isInvalidParts(CollisionParts* collisionParts) override; + bool isInvalidParts(const CollisionParts& collisionParts) const override; private: const LiveActor* mActor; @@ -222,7 +222,7 @@ class CollisionPartsFilterSpecialPurpose : public CollisionPartsFilterBase { CollisionPartsFilterSpecialPurpose(const char* specialPurpose) : mSpecialPurpose(specialPurpose) {} - bool isInvalidParts(CollisionParts* collisionParts) override; + bool isInvalidParts(const CollisionParts& collisionParts) const override; private: const char* mSpecialPurpose; @@ -233,7 +233,7 @@ class CollisionPartsFilterIgnoreOptionalPurpose : public CollisionPartsFilterBas CollisionPartsFilterIgnoreOptionalPurpose(const char* specialPurpose) : mSpecialPurpose(specialPurpose) {} - bool isInvalidParts(CollisionParts* collisionParts) override; + bool isInvalidParts(const CollisionParts& collisionParts) const override; private: const char* mSpecialPurpose; @@ -245,7 +245,7 @@ class CollisionPartsFilterMergePair : public CollisionPartsFilterBase { CollisionPartsFilterBase* secondFilter) : mFirstFilter(firstFilter), mSecondFilter(secondFilter) {} - bool isInvalidParts(CollisionParts* collisionParts) override; + bool isInvalidParts(const CollisionParts& collisionParts) const override; private: CollisionPartsFilterBase* mFirstFilter; diff --git a/lib/al/Library/Obj/CameraRailHolder.h b/lib/al/Library/Obj/CameraRailHolder.h index 353ca2710c..36173e8dea 100644 --- a/lib/al/Library/Obj/CameraRailHolder.h +++ b/lib/al/Library/Obj/CameraRailHolder.h @@ -10,6 +10,10 @@ class CameraRailHolder : public LiveActor { CameraRailHolder(const char* name); void init(const ActorInitInfo& info) override; + s32 getRailCount() const { return mCameraRailCount; } + + CameraLimitRailKeeper* getRail(s32 index) { return mCameraRails[index]; } + private: s32 mCameraRailCount = 0; CameraLimitRailKeeper** mCameraRails = nullptr; diff --git a/lib/al/Project/Camera/CameraAngleCtrlInfo.h b/lib/al/Project/Camera/CameraAngleCtrlInfo.h index 55dbc6ff81..2cdc354510 100644 --- a/lib/al/Project/Camera/CameraAngleCtrlInfo.h +++ b/lib/al/Project/Camera/CameraAngleCtrlInfo.h @@ -24,20 +24,31 @@ class CameraAngleCtrlInfo { bool receiveRequestFromObject(const CameraObjectRequestInfo& info); void setAngleV(f32 angleV); + void setDefaultAngleV(f32 min, f32 max) { + mDefaultMinAngleV = min; + mDefaultMaxAngleV = max; + } + + void setStartAngleV(f32 angle) { mStartAngleV = angle; } + + f32 getAngleH() const { return mAngleH; } + + f32 getAngleV() const { return mAngleV; } + private: void* _0; // object of size 0x14 void* _8; // object of size 0x10 bool mIsValidRotateH; s32 _14; - f32 _18; + f32 mAngleH; f32 _1c; f32 mMinAngleH; f32 mMaxAngleH; - f32 _28; f32 mAngleV; + f32 mStartAngleV; f32 _30; - f32 mMinAngleV; - f32 mMaxAngleV; + f32 mDefaultMinAngleV; + f32 mDefaultMaxAngleV; f32 _3c; f32 _40; f32 _44; diff --git a/lib/al/Project/Camera/CameraCollisionPartsFilter.h b/lib/al/Project/Camera/CameraCollisionPartsFilter.h new file mode 100644 index 0000000000..a7fbd6cd8c --- /dev/null +++ b/lib/al/Project/Camera/CameraCollisionPartsFilter.h @@ -0,0 +1,16 @@ +#pragma once + +#include "Library/Collision/KCollisionServer.h" + +namespace al { + +class CameraCollisionPartsFilter : public CollisionPartsFilterBase { +public: + CameraCollisionPartsFilter(); + + bool isInvalidParts(const CollisionParts&) const override; +}; + +static_assert(sizeof(CameraCollisionPartsFilter) == 0x8); + +} // namespace al diff --git a/src/Player/PlayerJudgeSleep.h b/src/Player/PlayerJudgeSleep.h index 20a399737c..13e053fa88 100644 --- a/src/Player/PlayerJudgeSleep.h +++ b/src/Player/PlayerJudgeSleep.h @@ -7,8 +7,8 @@ class PlayerStateWait; class PlayerJudgeSleep : public IJudge { public: PlayerJudgeSleep(const PlayerStateWait* stateWait); - void reset() override{}; - void update() override{}; + void reset() override {}; + void update() override {}; bool judge() const override; private: From 5c3055585f1ae7eba1a7a858b71a9112cb365cb7 Mon Sep 17 00:00:00 2001 From: Narr the Reg <5944268+german77@users.noreply.github.com> Date: Sun, 26 Jul 2026 17:26:12 -0600 Subject: [PATCH 4/7] First review --- lib/al/Library/Camera/CameraArrowCollider.h | 3 +-- lib/al/Library/Camera/CameraPoserFunction.cpp | 4 ++-- .../Library/Camera/CameraRequestParamHolder.h | 8 ++++---- .../Camera/CameraTargetCollideInfoHolder.h | 14 +++++++++----- lib/al/Library/Camera/CameraTargetHolder.h | 4 ++-- lib/al/Library/Camera/SnapShotCameraCtrl.h | 18 +++++++++--------- lib/al/Library/Obj/CameraRailHolder.h | 2 +- 7 files changed, 28 insertions(+), 25 deletions(-) diff --git a/lib/al/Library/Camera/CameraArrowCollider.h b/lib/al/Library/Camera/CameraArrowCollider.h index 57afa9bb19..a972f9ac1c 100644 --- a/lib/al/Library/Camera/CameraArrowCollider.h +++ b/lib/al/Library/Camera/CameraArrowCollider.h @@ -32,9 +32,8 @@ class CameraArrowCollider : public NerveExecutor, public IUseCollision { void set_48c(bool idx) { _48c = idx; } private: - char mBuffer[0x474]; + char filler_18[0x474]; bool _48c; - char mBuffer2[0x3]; }; static_assert(sizeof(CameraArrowCollider) == 0x490); diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp index 073aad65be..8de8e21a3c 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.cpp +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -443,11 +443,11 @@ bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* camera } f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser) { - return cameraPoser->getSceneInfo()->requestParamHolder->get_60(); + return cameraPoser->getSceneInfo()->requestParamHolder->getBossDistanceCurve(); } f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) { - return cameraPoser->getSceneInfo()->requestParamHolder->get_58(); + return cameraPoser->getSceneInfo()->requestParamHolder->getEquipmentDistanceCurve(); } bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser) { diff --git a/lib/al/Library/Camera/CameraRequestParamHolder.h b/lib/al/Library/Camera/CameraRequestParamHolder.h index 8fdfcae38c..458dcf90e4 100644 --- a/lib/al/Library/Camera/CameraRequestParamHolder.h +++ b/lib/al/Library/Camera/CameraRequestParamHolder.h @@ -35,9 +35,9 @@ class CameraRequestParamHolder { void setGyroSensitivityLevel(s32 level) { mGyroSensitivityLevel = level; } - f32* get_60() const { return _60; } + f32* getBossDistanceCurve() const { return mBossDistanceCurve; } - f32* get_58() const { return _58; } + f32* getEquipmentDistanceCurve() const { return mEquipmentDistanceCurve; } bool isOnRideObj() const { return mRideObjCamera && mIsCurrRideObj; } @@ -59,8 +59,8 @@ class CameraRequestParamHolder { bool mIsCurrRideObj = false; bool mIsPrevRideObj = false; const IUseCamera* mRideObjCamera = nullptr; - f32* _58 = nullptr; - f32* _60 = nullptr; + f32* mEquipmentDistanceCurve = nullptr; + f32* mBossDistanceCurve = nullptr; }; static_assert(sizeof(CameraRequestParamHolder) == 0x68); diff --git a/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h b/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h index 6b30850e90..a9de6d549b 100644 --- a/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h +++ b/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h @@ -15,7 +15,8 @@ class CameraTargetCollideInfoHolder : public IUseCollision, public IUseHioNode { void reset(); bool isExistUnderWall() const; bool tryCalcSlopDownFrontDirH(sead::Vector3f*) const; - CollisionDirector* getCollisionDirector() const override; + + CollisionDirector* getCollisionDirector() const override { return mCollisionDirector; } bool isExistCollisionUnderTarget() const { return mIsExistCollisionUnderTarget; } @@ -30,16 +31,19 @@ class CameraTargetCollideInfoHolder : public IUseCollision, public IUseHioNode { f32 getSlopeCollisionDownSpeed() const { return mSlopeCollisionDownSpeed; } private: - void* mBuffer; - char mBuffer2; + CollisionDirector* mCollisionDirector; + bool _10; bool mIsExistCollisionUnderTarget; - void* mBuffer3; + sead::Vector3f _14; sead::Vector3f mTargetCollisionNormal; sead::Vector3f mTargetCollisionPos; bool mIsExistSlopeCollisionUnderTarget; - char mBuffer4[0xc]; + sead::Vector3f _3c; f32 mSlopeCollisionDownSpeed; f32 mSlopeCollisionUpSpeed; + s32 _50; }; +static_assert(sizeof(CameraTargetCollideInfoHolder) == 0x58); + } // namespace al diff --git a/lib/al/Library/Camera/CameraTargetHolder.h b/lib/al/Library/Camera/CameraTargetHolder.h index b6ccf87762..a892a03bb1 100644 --- a/lib/al/Library/Camera/CameraTargetHolder.h +++ b/lib/al/Library/Camera/CameraTargetHolder.h @@ -11,13 +11,13 @@ class CameraSubTargetBase; struct ViewTargetInfo { CameraTargetBase* target = nullptr; - // Note: s8 is used instead of bool to match isChangeViewTarget + // NOTE: s8 is used instead of bool to match isChangeViewTarget s8 hasTargetChanged = false; }; struct ViewSubTargetInfo { CameraSubTargetBase* target = nullptr; - // Note: s8 is used instead of bool to match isChangeSubTarget + // NOTE: s8 is used instead of bool to match isChangeSubTarget s8 hasTargetChanged = false; }; diff --git a/lib/al/Library/Camera/SnapShotCameraCtrl.h b/lib/al/Library/Camera/SnapShotCameraCtrl.h index ad6604f99c..a112a1d2c5 100644 --- a/lib/al/Library/Camera/SnapShotCameraCtrl.h +++ b/lib/al/Library/Camera/SnapShotCameraCtrl.h @@ -30,23 +30,23 @@ class SnapShotCameraCtrl : public NerveExecutor, public IUseAudioKeeper { void exeWait(); void exeReset(); - f32 getFovyDegree() const { return mFovyDegree; }; - AudioKeeper* getAudioKeeper() const override; - void setIsValidLookAtOffset(bool isValid) { mIsValidLookAtOffset = isValid; }; + f32 getFovyDegree() const { return mFovyDegree; } + + void setIsValidLookAtOffset(bool isValid) { mIsValidLookAtOffset = isValid; } - void setIsValidZoomFovy(bool isValid) { mIsValidZoomFovy = isValid; }; + void setIsValidZoomFovy(bool isValid) { mIsValidZoomFovy = isValid; } - void setIsValidRoll(bool isValid) { mIsValidRoll = isValid; }; + void setIsValidRoll(bool isValid) { mIsValidRoll = isValid; } - void set_68(bool isValid) { _68 = isValid; }; + void set_68(bool isValid) { _68 = isValid; } - void setMaxZoomOutFovyDegree(f32 value) { mMaxZoomOutFovyDegree = value; }; + void setMaxZoomOutFovyDegree(f32 value) { mMaxZoomOutFovyDegree = value; } - f32 getRollDegree() const { return mRollDegree; }; + f32 getRollDegree() const { return mRollDegree; } - const sead::Vector3f& getLookAtOffset() const { return mLookAtOffset; }; + const sead::Vector3f& getLookAtOffset() const { return mLookAtOffset; } private: SnapShotCameraSceneInfo* mCameraSceneInfo; diff --git a/lib/al/Library/Obj/CameraRailHolder.h b/lib/al/Library/Obj/CameraRailHolder.h index 36173e8dea..e38703355d 100644 --- a/lib/al/Library/Obj/CameraRailHolder.h +++ b/lib/al/Library/Obj/CameraRailHolder.h @@ -12,7 +12,7 @@ class CameraRailHolder : public LiveActor { s32 getRailCount() const { return mCameraRailCount; } - CameraLimitRailKeeper* getRail(s32 index) { return mCameraRails[index]; } + CameraLimitRailKeeper* getRail(s32 index) const { return mCameraRails[index]; } private: s32 mCameraRailCount = 0; From b9bc43997865b956e81a8d61f12dd851d1b121dd Mon Sep 17 00:00:00 2001 From: Narr the Reg <5944268+german77@users.noreply.github.com> Date: Sun, 2 Aug 2026 08:04:28 -0600 Subject: [PATCH 5/7] Second review --- lib/al/Library/Camera/CameraPoserFunction.cpp | 4 ++-- lib/al/Library/Camera/CameraPoserFunction.h | 12 ++++++------ lib/al/Library/Camera/CameraRequestParamHolder.h | 9 +++++---- 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp index 8de8e21a3c..c94633cdb0 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.cpp +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -442,11 +442,11 @@ bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* camera return false; } -f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser) { +al::CameraDistanceCurve* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser) { return cameraPoser->getSceneInfo()->requestParamHolder->getBossDistanceCurve(); } -f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) { +al::CameraDistanceCurve* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) { return cameraPoser->getSceneInfo()->requestParamHolder->getEquipmentDistanceCurve(); } diff --git a/lib/al/Library/Camera/CameraPoserFunction.h b/lib/al/Library/Camera/CameraPoserFunction.h index 20b25cd2b6..a175b567b3 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.h +++ b/lib/al/Library/Camera/CameraPoserFunction.h @@ -5,16 +5,16 @@ #include namespace sead { -class Projection; class LookAtCamera; +class Projection; } // namespace sead namespace al { -class CameraPoser; +class CameraDistanceCurve; class CameraLimitRailKeeper; -class Projection; -struct CameraStartInfo; struct CameraObjectRequestInfo; +class CameraPoser; +struct CameraStartInfo; class IUseCollision; class PlacementInfo; class Projection; @@ -96,8 +96,8 @@ f32 calcTargetJumpSpeed(const al::CameraPoser* cameraPoser); f32 calcTargetFallSpeed(const al::CameraPoser* cameraPoser); bool isChangeTarget(const al::CameraPoser* cameraPoser); bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* cameraPoser); -f32* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser); -f32* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser); +al::CameraDistanceCurve* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser); +al::CameraDistanceCurve* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser); bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser); const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser* cameraPoser); const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser* cameraPoser); diff --git a/lib/al/Library/Camera/CameraRequestParamHolder.h b/lib/al/Library/Camera/CameraRequestParamHolder.h index 458dcf90e4..abef17f8d6 100644 --- a/lib/al/Library/Camera/CameraRequestParamHolder.h +++ b/lib/al/Library/Camera/CameraRequestParamHolder.h @@ -4,6 +4,7 @@ namespace al { class IUseCamera; +class CameraDistanceCurve; class CameraRequestParamHolder { public: @@ -35,9 +36,9 @@ class CameraRequestParamHolder { void setGyroSensitivityLevel(s32 level) { mGyroSensitivityLevel = level; } - f32* getBossDistanceCurve() const { return mBossDistanceCurve; } + CameraDistanceCurve* getBossDistanceCurve() const { return mBossDistanceCurve; } - f32* getEquipmentDistanceCurve() const { return mEquipmentDistanceCurve; } + CameraDistanceCurve* getEquipmentDistanceCurve() const { return mEquipmentDistanceCurve; } bool isOnRideObj() const { return mRideObjCamera && mIsCurrRideObj; } @@ -59,8 +60,8 @@ class CameraRequestParamHolder { bool mIsCurrRideObj = false; bool mIsPrevRideObj = false; const IUseCamera* mRideObjCamera = nullptr; - f32* mEquipmentDistanceCurve = nullptr; - f32* mBossDistanceCurve = nullptr; + CameraDistanceCurve* mEquipmentDistanceCurve = nullptr; + CameraDistanceCurve* mBossDistanceCurve = nullptr; }; static_assert(sizeof(CameraRequestParamHolder) == 0x68); From 561d3206a223c9191b72a67277c51139f3f71b03 Mon Sep 17 00:00:00 2001 From: Narr the Reg <5944268+german77@users.noreply.github.com> Date: Tue, 4 Aug 2026 10:45:44 -0600 Subject: [PATCH 6/7] Second review --- lib/al/Library/Camera/CameraPoser.h | 2 -- lib/al/Library/Camera/CameraPoserFunction.cpp | 36 +++++++++---------- .../Play/Camera/CameraVerticalAbsorber.cpp | 4 +-- .../Play/Camera/CameraVerticalAbsorber.h | 2 +- 4 files changed, 19 insertions(+), 25 deletions(-) diff --git a/lib/al/Library/Camera/CameraPoser.h b/lib/al/Library/Camera/CameraPoser.h index 993e653018..909aed5ee2 100644 --- a/lib/al/Library/Camera/CameraPoser.h +++ b/lib/al/Library/Camera/CameraPoser.h @@ -221,8 +221,6 @@ class CameraPoser : public HioNode, CameraViewInfo* getViewInfo() const { return mViewInfo; } - CameraViewInfo* getCameraViewInfo() const { return mViewInfo; } - CameraOffsetCtrlPreset* getCameraOffsetCtrlPreset() const { return mOffsetCtrlPreset; } CameraPoserSceneInfo* getSceneInfo() const { return mSceneInfo; } diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp index c94633cdb0..e49873b665 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.cpp +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -47,16 +47,12 @@ static sead::Vector3f sMtxX = {-1.0f, 0.0f, 0.0f}; static sead::Vector3f sMtxY = {0.0f, 1.0f, 0.0f}; static sead::Vector3f sMtxZ = {0.0f, 0.0f, -1.0f}; -static inline s32 getViewInfoIndex(const al::CameraPoser* cameraPoser) { - return cameraPoser->getViewInfo()->getIndex(); -} - static inline al::CameraTargetBase* getTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->getViewTarget(getViewInfoIndex(cameraPoser)); + return cameraPoser->getTargetHolder()->getViewTarget(getViewIndex(cameraPoser)); } static inline al::CameraTargetBase* tryGetTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->tryGetViewTarget(getViewInfoIndex(cameraPoser)); + return cameraPoser->getTargetHolder()->tryGetViewTarget(getViewIndex(cameraPoser)); } static inline al::CameraVerticalAbsorber* getVerticalAbsorber(const al::CameraPoser* cameraPoser) { @@ -69,7 +65,7 @@ getTargetCollision(const al::CameraPoser* cameraPoser) { } static inline al::ICameraInput* getCameraInput(const al::CameraPoser* cameraPoser) { - return cameraPoser->getInputHolder()->getInput(getViewInfoIndex(cameraPoser)); + return cameraPoser->getInputHolder()->getInput(getViewIndex(cameraPoser)); } static inline al::CameraSubTargetBase* getTopSubTarget(const al::CameraPoser* cameraPoser) { @@ -82,35 +78,35 @@ getSubTargetTurnParam(const al::CameraPoser* cameraPoser) { } s32 getViewIndex(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getIndex(); + return cameraPoser->getViewInfo()->getIndex(); } const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getLookAtCam(); + return cameraPoser->getViewInfo()->getLookAtCam(); } const sead::Projection& getProjectionSead(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getProjectionSead(); + return cameraPoser->getViewInfo()->getProjectionSead(); } const al::Projection& getProjection(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getProjection(); + return cameraPoser->getViewInfo()->getProjection(); } const sead::Matrix44f& getProjectionMtx(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getProjMtx(); + return cameraPoser->getViewInfo()->getProjMtx(); } f32 getNear(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getNear(); + return cameraPoser->getViewInfo()->getNear(); } f32 getFar(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getFar(); + return cameraPoser->getViewInfo()->getFar(); } f32 getAspect(const al::CameraPoser* cameraPoser) { - return cameraPoser->getCameraViewInfo()->getAspect(); + return cameraPoser->getViewInfo()->getAspect(); } const sead::Vector3f& getPreCameraPos(const al::CameraPoser* cameraPoser) { @@ -159,9 +155,9 @@ bool isPrePriorityPlayer(const al::CameraStartInfo& cameraStartInfo) { } bool isEqualPreCameraName(const al::CameraStartInfo& cameraStartInfo, const char* cameraName) { - if (cameraStartInfo.preCameraName) - return al::isEqualString(cameraName, cameraStartInfo.preCameraName); - return false; + if (!cameraStartInfo.preCameraName) + return false; + return al::isEqualString(cameraName, cameraStartInfo.preCameraName); } bool isPreCameraFixAbsolute(const al::CameraStartInfo& cameraStartInfo) { @@ -263,7 +259,7 @@ bool calcLookDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) { void calcSideDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) { sead::Vector3f facingDir = cameraPoser->getEye() - cameraPoser->getAt(); al::normalize(&facingDir); - outDir->set(facingDir.cross(cameraPoser->getUp())); + outDir->setCross(facingDir, cameraPoser->getUp()); al::normalize(outDir); } @@ -428,7 +424,7 @@ f32 calcTargetFallSpeed(const al::CameraPoser* cameraPoser) { } bool isChangeTarget(const al::CameraPoser* cameraPoser) { - return cameraPoser->getTargetHolder()->isChangeViewTarget(getViewInfoIndex(cameraPoser)); + return cameraPoser->getTargetHolder()->isChangeViewTarget(getViewIndex(cameraPoser)); } bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* cameraPoser) { diff --git a/lib/al/Library/Play/Camera/CameraVerticalAbsorber.cpp b/lib/al/Library/Play/Camera/CameraVerticalAbsorber.cpp index d8f1251ed6..a050df6f26 100644 --- a/lib/al/Library/Play/Camera/CameraVerticalAbsorber.cpp +++ b/lib/al/Library/Play/Camera/CameraVerticalAbsorber.cpp @@ -27,9 +27,9 @@ NERVES_MAKE_STRUCT(CameraVerticalAbsorber, FollowGround, FollowAbsolute, FollowC namespace al { CameraVerticalAbsorber::CameraVerticalAbsorber(const CameraPoser* cameraParent, - bool isCameraPosAbsorb) + bool isNoCameraPosAbsorb) : NerveExecutor("カメラの縦パン"), mCameraPoser(cameraParent), - mIsNoCameraPosAbsorb(isCameraPosAbsorb) { + mIsNoCameraPosAbsorb(isNoCameraPosAbsorb) { initNerve(&NrvCameraVerticalAbsorber.FollowGround); } diff --git a/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h b/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h index 95b5233e38..4e89311636 100644 --- a/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h +++ b/lib/al/Library/Play/Camera/CameraVerticalAbsorber.h @@ -12,7 +12,7 @@ struct CameraStartInfo; class CameraVerticalAbsorber : public NerveExecutor { public: - CameraVerticalAbsorber(const CameraPoser* cameraParent, bool isCameraPosAbsorb); + CameraVerticalAbsorber(const CameraPoser* cameraParent, bool isNoCameraPosAbsorb); void load(const ByamlIter& iter); void start(const sead::Vector3f& pos, const CameraStartInfo& info); From 3c6ec48e13a8e5d34245d7e3b77bf36c8a7b2271 Mon Sep 17 00:00:00 2001 From: Narr the Reg <5944268+german77@users.noreply.github.com> Date: Fri, 7 Aug 2026 10:14:54 -0600 Subject: [PATCH 7/7] Third review --- lib/al/Library/Camera/CameraPoser.h | 2 +- lib/al/Library/Camera/CameraPoserFunction.cpp | 54 +++++++++---------- lib/al/Library/Camera/CameraPoserFunction.h | 8 ++- 3 files changed, 35 insertions(+), 29 deletions(-) diff --git a/lib/al/Library/Camera/CameraPoser.h b/lib/al/Library/Camera/CameraPoser.h index 909aed5ee2..c9a980ba89 100644 --- a/lib/al/Library/Camera/CameraPoser.h +++ b/lib/al/Library/Camera/CameraPoser.h @@ -235,7 +235,7 @@ class CameraPoser : public HioNode, GyroCameraCtrl* getGyroCtrl() const { return mGyroCtrl; } - CameraPoserFlag* getPoserFag() const { return mPoserFlag; } + CameraPoserFlag* getPoserFlag() const { return mPoserFlag; } SnapShotCameraCtrl* getSnapShotCtrl() const { return mSnapShotCtrl; } diff --git a/lib/al/Library/Camera/CameraPoserFunction.cpp b/lib/al/Library/Camera/CameraPoserFunction.cpp index e49873b665..5d9761e670 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.cpp +++ b/lib/al/Library/Camera/CameraPoserFunction.cpp @@ -40,7 +40,7 @@ #include "Project/Camera/CameraSubTargetTurnParam.h" namespace alCameraPoserFunction { -static al::CameraCollisionPartsFilter sPartsFiler; +static al::CameraCollisionPartsFilter sPartsFilter; static al::CameraTriangleFilter sTriangleFilter; static al::CameraTriangleFilterOnlyCeiling sCeilFilter; static sead::Vector3f sMtxX = {-1.0f, 0.0f, 0.0f}; @@ -755,15 +755,15 @@ void reduceGyroSencitivity(al::CameraPoser* cameraPoser) { } void stopUpdateGyro(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isStopUpdateGyro = true; + cameraPoser->getPoserFlag()->isStopUpdateGyro = true; } void restartUpdateGyro(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isStopUpdateGyro = false; + cameraPoser->getPoserFlag()->isStopUpdateGyro = false; } bool isStopUpdateGyro(const al::CameraPoser* cameraPoser) { - return cameraPoser->getPoserFag()->isStopUpdateGyro; + return cameraPoser->getPoserFlag()->isStopUpdateGyro; } bool isTargetCollideGround(const al::CameraPoser* cameraPoser) { @@ -861,19 +861,19 @@ const sead::Vector3f& getSnapShotLookAtOffset(const al::CameraPoser* cameraPoser } bool isOffVerticalAbsorb(const al::CameraPoser* cameraPoser) { - return cameraPoser->getPoserFag()->isOffVerticalAbsorb; + return cameraPoser->getPoserFlag()->isOffVerticalAbsorb; } void onVerticalAbsorb(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isOffVerticalAbsorb = false; + cameraPoser->getPoserFlag()->isOffVerticalAbsorb = false; } void offVerticalAbsorb(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isOffVerticalAbsorb = true; + cameraPoser->getPoserFlag()->isOffVerticalAbsorb = true; } void invalidateCameraBlur(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidCameraBlur = true; + cameraPoser->getPoserFlag()->isInvalidCameraBlur = true; } bool isRequestStopVerticalAbsorb(const al::CameraObjectRequestInfo& requestInfo) { @@ -917,39 +917,39 @@ f32 getRequestAngleV(const al::CameraObjectRequestInfo& requestInfo) { } bool isInvalidCollider(const al::CameraPoser* cameraPoser) { - return cameraPoser->getPoserFag()->isInvalidCollider; + return cameraPoser->getPoserFlag()->isInvalidCollider; } void validateCollider(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidCollider = false; + cameraPoser->getPoserFlag()->isInvalidCollider = false; } void invalidateCollider(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidCollider = true; + cameraPoser->getPoserFlag()->isInvalidCollider = true; } void validateCtrlSubjective(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isValidCtrlSubjective = true; + cameraPoser->getPoserFlag()->isValidCtrlSubjective = true; } void invalidateChangeSubjective(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidChangeSubjective = true; + cameraPoser->getPoserFlag()->isInvalidChangeSubjective = true; } void invalidateKeepDistanceNextCamera(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidKeepDistanceNextCamera = true; + cameraPoser->getPoserFlag()->isInvalidKeepDistanceNextCamera = true; } void invalidateKeepDistanceNextCameraIfNoCollide(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidKeepDistanceNextCameraIfNoCollide = true; + cameraPoser->getPoserFlag()->isInvalidKeepDistanceNextCameraIfNoCollide = true; } void invalidatePreCameraEndAfterInterpole(al::CameraPoser* cameraPoser) { - cameraPoser->getPoserFag()->isInvalidPreCameraEndAfterInterpole = true; + cameraPoser->getPoserFlag()->isInvalidPreCameraEndAfterInterpole = true; } bool isInvalidPreCameraEndAfterInterpole(const al::CameraPoser* cameraPoser) { - return cameraPoser->getPoserFag()->isInvalidPreCameraEndAfterInterpole; + return cameraPoser->getPoserFlag()->isInvalidPreCameraEndAfterInterpole; } bool isSceneCameraFirstCalc(const al::CameraPoser* cameraPoser) { @@ -988,7 +988,7 @@ bool checkFirstCameraCollisionArrow(CameraCollisionHitResult* outResult, const sead::Vector3f& dir) { const al::ArrowHitInfo* hitInfo = nullptr; - if (!alCollisionUtil::getFirstPolyOnArrow(collision, &hitInfo, pos, dir, &sPartsFiler, + if (!alCollisionUtil::getFirstPolyOnArrow(collision, &hitInfo, pos, dir, &sPartsFilter, &sTriangleFilter)) { return false; } @@ -996,11 +996,11 @@ bool checkFirstCameraCollisionArrow(CameraCollisionHitResult* outResult, outResult->hitPos.set(hitInfo->hitInfo->collisionHitPos); outResult->normal.set(hitInfo->hitInfo->triangle.getNormal(0)); - s32 type = 2; + CameraCollisionHitType type = CameraCollisionHitType::Default; if (hitInfo->hitInfo->isCollisionAtFace()) - type = 0; + type = CameraCollisionHitType::Face; else if (hitInfo->hitInfo->isCollisionAtEdge()) - type = 1; + type = CameraCollisionHitType::Edge; outResult->type = type; @@ -1072,12 +1072,12 @@ void rotateVecZone(sead::Vector3f* outVec, const sead::Vector3f& vec, bool makeCameraKeepInFrameV(sead::LookAtCamera* camera, const sead::Vector3f& vec, const al::CameraPoser* cameraPoser, f32 a, f32 b) { sead::Vector3f offset = {0.0f, 0.0f, 0.0f}; - if (calcOffsetCameraKeepInFrameV(&offset, camera, vec, cameraPoser, a, b)) { - camera->setAt(camera->getAt() + offset); - camera->setPos(camera->getPos() + offset); - return true; - } - return false; + if (!calcOffsetCameraKeepInFrameV(&offset, camera, vec, cameraPoser, a, b)) + return false; + + camera->setAt(camera->getAt() + offset); + camera->setPos(camera->getPos() + offset); + return true; } void initCameraRail(al::CameraPoser* cameraPoser, const al::PlacementInfo& info, const char* name) { diff --git a/lib/al/Library/Camera/CameraPoserFunction.h b/lib/al/Library/Camera/CameraPoserFunction.h index a175b567b3..f6eea0e646 100644 --- a/lib/al/Library/Camera/CameraPoserFunction.h +++ b/lib/al/Library/Camera/CameraPoserFunction.h @@ -22,10 +22,16 @@ class Projection; } // namespace al namespace alCameraPoserFunction { +enum class CameraCollisionHitType { + Face, + Edge, + Default, +}; + struct CameraCollisionHitResult { sead::Vector3f hitPos = {0.0f, 0.0f, 0.0f}; sead::Vector3f normal = {0.0f, 0.0f, 0.0f}; - s32 type = 2; + CameraCollisionHitType type = CameraCollisionHitType::Default; }; s32 getViewIndex(const al::CameraPoser* cameraPoser);