diff --git a/data/file_list.yml b/data/file_list.yml index 78b297b24c..5c08943335 100644 --- a/data/file_list.yml +++ b/data/file_list.yml @@ -227881,19 +227881,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 @@ -227901,407 +227901,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 456352d369..5db1a956c3 100644 --- a/lib/al/Library/Camera/CameraPoser.h +++ b/lib/al/Library/Camera/CameraPoser.h @@ -213,6 +213,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 setPosition(const sead::Vector3f& vec) { mPosition.set(vec); }; @@ -224,6 +232,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: