diff --git a/data/file_list.yml b/data/file_list.yml
index f5f6c5b477..8304f1ff70 100644
--- a/data/file_list.yml
+++ b/data/file_list.yml
@@ -228799,723 +228799,723 @@ 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
-    status: NotDecompiled
+    status: Matching
   - 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
-    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/CameraArrowCollider.h b/lib/al/Library/Camera/CameraArrowCollider.h
index ad8e90f02f..a972f9ac1c 100644
--- a/lib/al/Library/Camera/CameraArrowCollider.h
+++ b/lib/al/Library/Camera/CameraArrowCollider.h
@@ -28,5 +28,13 @@ class CameraArrowCollider : public NerveExecutor, public IUseCollision {
 
     bool isShrink() const;
     f32 getPushLength() const;
+
+    void set_48c(bool idx) { _48c = idx; }
+
+private:
+    char filler_18[0x474];
+    bool _48c;
 };
+
+static_assert(sizeof(CameraArrowCollider) == 0x490);
 }  // namespace al
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 cb2e167c2e..c9a980ba89 100644
--- a/lib/al/Library/Camera/CameraPoser.h
+++ b/lib/al/Library/Camera/CameraPoser.h
@@ -221,6 +221,24 @@ class CameraPoser : public HioNode,
 
     CameraViewInfo* getViewInfo() const { return mViewInfo; }
 
+    CameraOffsetCtrlPreset* getCameraOffsetCtrlPreset() const { return mOffsetCtrlPreset; }
+
+    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* getPoserFlag() const { return mPoserFlag; }
+
+    SnapShotCameraCtrl* getSnapShotCtrl() const { return mSnapShotCtrl; }
+
     // set
     void setEye(const sead::Vector3f& pos) { mEye.set(pos); }
 
@@ -234,6 +252,22 @@ class CameraPoser : public HioNode,
 
     void setFovyDegree(f32 fovy) { mFovyDegree = fovy; }
 
+    void setVerticalAbsorber(CameraVerticalAbsorber* cameraVerticalAbsorber) {
+        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
new file mode 100644
index 0000000000..5d9761e670
--- /dev/null
+++ b/lib/al/Library/Camera/CameraPoserFunction.cpp
@@ -0,0 +1,1250 @@
+#include "Library/Camera/CameraPoserFunction.h"
+
+#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"
+#include "Library/Camera/CameraSubTargetBase.h"
+#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 sPartsFilter;
+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 al::CameraTargetBase* getTarget(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getTargetHolder()->getViewTarget(getViewIndex(cameraPoser));
+}
+
+static inline al::CameraTargetBase* tryGetTarget(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getTargetHolder()->tryGetViewTarget(getViewIndex(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(getViewIndex(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->getViewInfo()->getIndex();
+}
+
+const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getLookAtCam();
+}
+
+const sead::Projection& getProjectionSead(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getProjectionSead();
+}
+
+const al::Projection& getProjection(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getProjection();
+}
+
+const sead::Matrix44f& getProjectionMtx(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getProjMtx();
+}
+
+f32 getNear(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getNear();
+}
+
+f32 getFar(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getFar();
+}
+
+f32 getAspect(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getViewInfo()->getAspect();
+}
+
+const sead::Vector3f& getPreCameraPos(const al::CameraPoser* cameraPoser) {
+    return getLookAtCamera(cameraPoser).getPos();
+}
+
+const sead::Vector3f& getPreLookAtPos(const al::CameraPoser* cameraPoser) {
+    return getLookAtCamera(cameraPoser).getAt();
+}
+
+const sead::Vector3f& getPreUpDir(const al::CameraPoser* cameraPoser) {
+    return getLookAtCamera(cameraPoser).getUp();
+}
+
+f32 getPreFovyDegree(const al::CameraPoser* cameraPoser) {
+    return sead::Mathf::rad2deg(getPreFovyRadian(cameraPoser));
+}
+
+f32 getPreFovyRadian(const al::CameraPoser* cameraPoser) {
+    return getProjection(cameraPoser).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 isPrePriorityDemo(cameraStartInfo) || isPrePriorityDemo2(cameraStartInfo);
+}
+
+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 false;
+    return al::isEqualString(cameraName, cameraStartInfo.preCameraName);
+}
+
+bool isPreCameraFixAbsolute(const al::CameraStartInfo& cameraStartInfo) {
+    return isEqualPreCameraName(cameraStartInfo, al::CameraPoserFix::getFixAbsoluteCameraName());
+}
+
+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* outPose, const al::CameraPoser* cameraPoser) {
+    sead::Vector3f lookDir;
+    calcLookDir(&lookDir, cameraPoser);
+    al::makeQuatFrontUp(outPose, lookDir, cameraPoser->getUp());
+}
+
+void calcLookDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    calcCameraDir(outDir, cameraPoser);
+    outDir->negate();
+}
+
+void calcCameraDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    outDir->setSub(cameraPoser->getEye(), cameraPoser->getAt());
+    al::normalize(outDir);
+}
+
+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* outDirH, const al::CameraPoser* cameraPoser) {
+    bool isValid = calcCameraDirH(outDirH, cameraPoser);
+    outDirH->negate();
+    return isValid;
+}
+
+void calcSideDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    sead::Vector3f facingDir = cameraPoser->getEye() - cameraPoser->getAt();
+    al::normalize(&facingDir);
+    outDir->setCross(facingDir, cameraPoser->getUp());
+    al::normalize(outDir);
+}
+
+void calcPreCameraDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser);
+    outDir->setSub(lookAtCam.getPos(), lookAtCam.getAt());
+    al::normalize(outDir);
+}
+
+void calcPreCameraDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) {
+    const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser);
+    outDirH->setSub(lookAtCam.getPos(), lookAtCam.getAt());
+    al::verticalizeVec(outDirH, sead::Vector3f::ey, *outDirH);
+    al::tryNormalizeOrZero(outDirH);
+}
+
+void calcPreLookDir(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    calcPreCameraDir(outDir, cameraPoser);
+    outDir->negate();
+}
+
+void calcPreLookDirH(sead::Vector3f* outDirH, const al::CameraPoser* cameraPoser) {
+    const sead::LookAtCamera& lookAtCam = getLookAtCamera(cameraPoser);
+    outDirH->set(lookAtCam.getAt() - lookAtCam.getPos());
+    al::verticalizeVec(outDirH, getPreUpDir(cameraPoser), *outDirH);
+    al::tryNormalizeOrZero(outDirH);
+}
+
+f32 calcPreCameraAngleH(const al::CameraPoser* cameraPoser) {
+    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) {
+    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 targetTrans = {0.0f, 0.0f, 0.0f};
+    calcTargetTrans(&targetTrans, cameraPoser);
+    cameraPoser->setAt(targetTrans);
+}
+
+void calcTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser) {
+    getTarget(cameraPoser)->calcTrans(outTrans);
+}
+
+void setLookAtPosToTargetAddOffset(al::CameraPoser* cameraPoser, const sead::Vector3f& offset) {
+    sead::Vector3f targetTrans = {0.0f, 0.0f, 0.0f};
+    calcTargetTrans(&targetTrans, cameraPoser);
+    cameraPoser->setAt(targetTrans + offset);
+}
+
+void setCameraPosToTarget(al::CameraPoser* cameraPoser) {
+    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 targetTrans = {0.0f, 0.0f, 0.0f};
+    calcTargetTrans(&targetTrans, cameraPoser);
+    cameraPoser->setEye(targetTrans + offset);
+}
+
+void calcTargetTransWithOffset(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser) {
+    calcTargetTrans(outTrans, cameraPoser);
+    al::CameraOffsetCtrlPreset* cameraOffsetCtrlPreset = cameraPoser->getCameraOffsetCtrlPreset();
+    if (cameraOffsetCtrlPreset)
+        outTrans->add(cameraOffsetCtrlPreset->getOffset());
+}
+
+void calcTargetVelocity(sead::Vector3f* outVelocity, const al::CameraPoser* cameraPoser) {
+    getTarget(cameraPoser)->calcVelocity(outVelocity);
+}
+
+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* outDir, const al::CameraPoser* cameraPoser) {
+    getTarget(cameraPoser)->calcUp(outDir);
+}
+
+f32 calcTargetSpeedV(const al::CameraPoser* cameraPoser) {
+    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();
+
+    if (direction > 0.0f)
+        return speedV;
+    else
+        return -speedV;
+}
+
+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(outPose, targetFront, targetUp);
+}
+
+void calcTargetFront(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    getTarget(cameraPoser)->calcFront(outDir);
+}
+
+void calcTargetSide(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    getTarget(cameraPoser)->calcSide(outDir);
+}
+
+void calcTargetGravity(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    getTarget(cameraPoser)->calcGravity(outDir);
+}
+
+f32 calcTargetSpeedH(const al::CameraPoser* cameraPoser) {
+    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 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 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) {
+    return cameraPoser->getTargetHolder()->isChangeViewTarget(getViewIndex(cameraPoser));
+}
+
+bool tryGetTargetRequestDistance(f32* outDistance, const al::CameraPoser* cameraPoser) {
+    al::CameraTargetBase* target = getTarget(cameraPoser);
+
+    if (target->getRequestDistance() > 0.0f) {
+        *outDistance = target->getRequestDistance();
+        return true;
+    }
+
+    return false;
+}
+
+al::CameraDistanceCurve* tryGetBossDistanceCurve(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getSceneInfo()->requestParamHolder->getBossDistanceCurve();
+}
+
+al::CameraDistanceCurve* tryGetEquipmentDistanceCurve(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getSceneInfo()->requestParamHolder->getEquipmentDistanceCurve();
+}
+
+bool isExistCollisionUnderTarget(const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->isExistCollisionUnderTarget();
+}
+
+const sead::Vector3f& getUnderTargetCollisionPos(const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->getTargetCollisionPos();
+}
+
+const sead::Vector3f& getUnderTargetCollisionNormal(const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->getTargetCollisionNormal();
+}
+
+bool isExistSlopeCollisionUnderTarget(const al::CameraPoser* cameraPoser) {
+    return isExistCollisionUnderTarget(cameraPoser) &&
+           getTargetCollision(cameraPoser)->isExistSlopeCollisionUnderTarget();
+}
+
+bool isExistWallCollisionUnderTarget(const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->isExistUnderWall();
+}
+
+bool tryCalcSlopeCollisionDownFrontDirH(sead::Vector3f* outDirH,
+                                        const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->tryCalcSlopDownFrontDirH(outDirH);
+}
+
+f32 getSlopeCollisionUpSpeed(const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->getSlopeCollisionUpSpeed();
+}
+
+f32 getSlopeCollisionDownSpeed(const al::CameraPoser* cameraPoser) {
+    return getTargetCollision(cameraPoser)->getSlopeCollisionDownSpeed();
+}
+
+bool isExistSubTarget(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getTargetHolder()->getTopSubTargetInfo().target;
+}
+
+bool checkValidTurnToSubTarget(const al::CameraPoser* cameraPoser) {
+    if (!isExistSubTarget(cameraPoser))
+        return false;
+
+    al::CameraSubTargetTurnParam* subTargetTurnParam = getSubTargetTurnParam(cameraPoser);
+    if (subTargetTurnParam->validTurnDegreeRangeH < 0.0f &&
+        subTargetTurnParam->validFaceDegreeRangeH != 0.0f) {
+        return true;
+    }
+
+    sead::Vector3f lookDirH = {};
+    if (!calcLookDirH(&lookDirH, cameraPoser))
+        return false;
+
+    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->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->validTurnDegreeRangeH / 2 < al::calcAngleDegree(lookDirH, lookDir))
+            return false;
+    }
+
+    return true;
+}
+
+void calcSubTargetBack(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    calcSubTargetFront(outDir, cameraPoser);
+    outDir->negate();
+}
+
+void calcSubTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser) {
+    getTopSubTarget(cameraPoser)->calcTrans(outTrans);
+}
+
+bool isChangeSubTarget(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getTargetHolder()->getTopSubTargetInfo().hasTargetChanged;
+}
+
+void calcSubTargetFront(sead::Vector3f* outDir, const al::CameraPoser* cameraPoser) {
+    getTopSubTarget(cameraPoser)->calcFront(outDir);
+}
+
+f32 getSubTargetRequestDistance(const al::CameraPoser* cameraPoser) {
+    return getTopSubTarget(cameraPoser)->getRequestDistance();
+}
+
+f32 getSubTargetTurnSpeedRate1(const al::CameraPoser* cameraPoser) {
+    return getSubTargetTurnParam(cameraPoser)->turnSpeedRate1;
+}
+
+f32 getSubTargetTurnSpeedRate2(const al::CameraPoser* cameraPoser) {
+    return getSubTargetTurnParam(cameraPoser)->turnSpeedRate2;
+}
+
+s32 getSubTargetTurnRestartStep(const al::CameraPoser* cameraPoser) {
+    return getSubTargetTurnParam(cameraPoser)->targetTurnRestartStep;
+}
+
+bool tryCalcSubTargetTurnBrakeDistanceRate(f32* outDistanceRate,
+                                           const al::CameraPoser* cameraPoser) {
+    al::CameraSubTargetTurnParam* turnParam = getSubTargetTurnParam(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(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) {
+        *outDistanceRate = 1.0f - al::normalize(distance, turnParam->turnBrakeEndDistance,
+                                                turnParam->turnBrakeStartDistance);
+        return true;
+    }
+
+    if (turnParam->turnStopStartDistance > 0.0f &&
+        turnParam->turnStopStartDistance < turnParam->turnStopEndDistance &&
+        turnParam->turnStopStartDistance < distance) {
+        *outDistanceRate = al::normalize(distance, turnParam->turnStopStartDistance,
+                                         turnParam->turnStopEndDistance);
+        return true;
+    }
+
+    return false;
+}
+
+bool isValidSubTargetTurnV(const al::CameraPoser* cameraPoser) {
+    return getSubTargetTurnParam(cameraPoser)->isTurnV;
+}
+
+bool isValidSubTargetResetAfterTurnV(const al::CameraPoser* cameraPoser) {
+    return getSubTargetTurnParam(cameraPoser)->isResetAfterTurnV;
+}
+
+void clampAngleSubTargetTurnRangeV(f32* outTurnRangeV, const al::CameraPoser* cameraPoser) {
+    al::CameraSubTargetBase* topSubTarget = getTopSubTarget(cameraPoser);
+    f32 min = topSubTarget->getSubTargetTurnParam()->minTurnDegreeV;
+    f32 max = topSubTarget->getSubTargetTurnParam()->maxTurnDegreeV;
+
+    *outTurnRangeV = sead::Mathf::clamp(*outTurnRangeV, min, max);
+}
+
+void initCameraVerticalAbsorber(al::CameraPoser* cameraPoser) {
+    cameraPoser->setVerticalAbsorber(new al::CameraVerticalAbsorber(cameraPoser, false));
+}
+
+void initCameraVerticalAbsorberNoCameraPosAbsorb(al::CameraPoser* cameraPoser) {
+    cameraPoser->setVerticalAbsorber(new al::CameraVerticalAbsorber(cameraPoser, true));
+}
+
+f32 getCameraVerticalAbsorbPosUp(const al::CameraPoser* cameraPoser) {
+    return getVerticalAbsorber(cameraPoser)->getAbsorbScreenPosUp();
+}
+
+f32 getCameraVerticalAbsorbPosDown(const al::CameraPoser* cameraPoser) {
+    return getVerticalAbsorber(cameraPoser)->getAbsorbScreenPosDown();
+}
+
+void liberateVerticalAbsorb(al::CameraPoser* cameraPoser) {
+    getVerticalAbsorber(cameraPoser)->liberateAbsorb();
+}
+
+void stopUpdateVerticalAbsorb(al::CameraPoser* cameraPoser) {
+    getVerticalAbsorber(cameraPoser)->setIsStopUpdate(true);
+}
+
+void stopUpdateVerticalAbsorbForSnapShotMode(al::CameraPoser* cameraPoser,
+                                             const sead::Vector3f& absorbVec) {
+    stopUpdateVerticalAbsorb(cameraPoser);
+    getVerticalAbsorber(cameraPoser)->tryResetAbsorbVecIfInCollision(absorbVec);
+}
+
+void restartUpdateVerticalAbsorb(al::CameraPoser* cameraPoser) {
+    getVerticalAbsorber(cameraPoser)->setIsStopUpdate(false);
+}
+
+void validateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser) {
+    getVerticalAbsorber(cameraPoser)->setIsKeepInFrame(true);
+}
+
+void invalidateVerticalAbsorbKeepInFrame(al::CameraPoser* cameraPoser) {
+    getVerticalAbsorber(cameraPoser)->setIsKeepInFrame(false);
+}
+
+void setVerticalAbsorbKeepInFrameScreenOffsetUp(al::CameraPoser* cameraPoser,
+                                                f32 keepInFrameOffsetUp) {
+    getVerticalAbsorber(cameraPoser)->setKeepInFrameOffsetUp(keepInFrameOffsetUp);
+}
+
+void setVerticalAbsorbKeepInFrameScreenOffsetDown(al::CameraPoser* cameraPoser,
+                                                  f32 keepInFrameOffsetDown) {
+    getVerticalAbsorber(cameraPoser)->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);
+}
+
+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->getPoserFlag()->isStopUpdateGyro = true;
+}
+
+void restartUpdateGyro(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isStopUpdateGyro = false;
+}
+
+bool isStopUpdateGyro(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getPoserFlag()->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->getPoserFlag()->isOffVerticalAbsorb;
+}
+
+void onVerticalAbsorb(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isOffVerticalAbsorb = false;
+}
+
+void offVerticalAbsorb(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isOffVerticalAbsorb = true;
+}
+
+void invalidateCameraBlur(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->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->getPoserFlag()->isInvalidCollider;
+}
+
+void validateCollider(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isInvalidCollider = false;
+}
+
+void invalidateCollider(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isInvalidCollider = true;
+}
+
+void validateCtrlSubjective(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isValidCtrlSubjective = true;
+}
+
+void invalidateChangeSubjective(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isInvalidChangeSubjective = true;
+}
+
+void invalidateKeepDistanceNextCamera(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isInvalidKeepDistanceNextCamera = true;
+}
+
+void invalidateKeepDistanceNextCameraIfNoCollide(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isInvalidKeepDistanceNextCameraIfNoCollide = true;
+}
+
+void invalidatePreCameraEndAfterInterpole(al::CameraPoser* cameraPoser) {
+    cameraPoser->getPoserFlag()->isInvalidPreCameraEndAfterInterpole = true;
+}
+
+bool isInvalidPreCameraEndAfterInterpole(const al::CameraPoser* cameraPoser) {
+    return cameraPoser->getPoserFlag()->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, &sPartsFilter,
+                                              &sTriangleFilter)) {
+        return false;
+    }
+
+    outResult->hitPos.set(hitInfo->hitInfo->collisionHitPos);
+    outResult->normal.set(hitInfo->hitInfo->triangle.getNormal(0));
+
+    CameraCollisionHitType type = CameraCollisionHitType::Default;
+    if (hitInfo->hitInfo->isCollisionAtFace())
+        type = CameraCollisionHitType::Face;
+    else if (hitInfo->hitInfo->isCollisionAtEdge())
+        type = CameraCollisionHitType::Edge;
+
+    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))
+        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) {
+    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 25c5b6bde3..f6eea0e646 100644
--- a/lib/al/Library/Camera/CameraPoserFunction.h
+++ b/lib/al/Library/Camera/CameraPoserFunction.h
@@ -5,241 +5,268 @@
 #include <math/seadVector.h>
 
 namespace sead {
-class Projection;
 class LookAtCamera;
+class Projection;
 }  // namespace sead
 
 namespace al {
+class CameraDistanceCurve;
+class CameraLimitRailKeeper;
+struct CameraObjectRequestInfo;
 class CameraPoser;
-class Projection;
 struct CameraStartInfo;
-struct CameraObjectRequestInfo;
 class IUseCollision;
 class PlacementInfo;
+class Projection;
+
 }  // namespace al
 
 namespace alCameraPoserFunction {
-class CameraCollisionHitResult;
+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};
+    CameraCollisionHitType type = CameraCollisionHitType::Default;
+};
 
-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*);
-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 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 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*);
-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 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*);
-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*);
+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);
+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);
+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* cameraName);
+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* 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* 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* 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* 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* outDistance, 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);
+bool isExistSlopeCollisionUnderTarget(const al::CameraPoser* cameraPoser);
+bool isExistWallCollisionUnderTarget(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* outDir, const al::CameraPoser* cameraPoser);
+void calcSubTargetTrans(sead::Vector3f* outTrans, const al::CameraPoser* cameraPoser);
+bool isChangeSubTarget(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* outDistanceRate,
+                                           const al::CameraPoser* cameraPoser);
+bool isValidSubTargetTurnV(const al::CameraPoser* cameraPoser);
+bool isValidSubTargetResetAfterTurnV(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);
+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);
+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);
+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* 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);
+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 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& 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);
+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* 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);
+// 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);
+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* outStick, 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/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 55846174c5..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,6 +36,12 @@ class CameraRequestParamHolder {
 
     void setGyroSensitivityLevel(s32 level) { mGyroSensitivityLevel = level; }
 
+    CameraDistanceCurve* getBossDistanceCurve() const { return mBossDistanceCurve; }
+
+    CameraDistanceCurve* getEquipmentDistanceCurve() const { return mEquipmentDistanceCurve; }
+
+    bool isOnRideObj() const { return mRideObjCamera && mIsCurrRideObj; }
+
 private:
     s32 mStickSensitivityLevel = 0;
     s32 mGyroSensitivityLevel = 0;
@@ -53,8 +60,9 @@ class CameraRequestParamHolder {
     bool mIsCurrRideObj = false;
     bool mIsPrevRideObj = false;
     const IUseCamera* mRideObjCamera = nullptr;
-    void* _58 = nullptr;
-    void* _60 = nullptr;
+    CameraDistanceCurve* mEquipmentDistanceCurve = nullptr;
+    CameraDistanceCurve* mBossDistanceCurve = nullptr;
 };
 
+static_assert(sizeof(CameraRequestParamHolder) == 0x68);
 }  // namespace al
diff --git a/lib/al/Library/Camera/CameraSubTargetBase.h b/lib/al/Library/Camera/CameraSubTargetBase.h
index 005f7943d2..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:
@@ -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..a9de6d549b
--- /dev/null
+++ b/lib/al/Library/Camera/CameraTargetCollideInfoHolder.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <math/seadVector.h>
+
+#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 { return mCollisionDirector; }
+
+    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:
+    CollisionDirector* mCollisionDirector;
+    bool _10;
+    bool mIsExistCollisionUnderTarget;
+    sead::Vector3f _14;
+    sead::Vector3f mTargetCollisionNormal;
+    sead::Vector3f mTargetCollisionPos;
+    bool mIsExistSlopeCollisionUnderTarget;
+    sead::Vector3f _3c;
+    f32 mSlopeCollisionDownSpeed;
+    f32 mSlopeCollisionUpSpeed;
+    s32 _50;
+};
+
+static_assert(sizeof(CameraTargetCollideInfoHolder) == 0x58);
+
+}  // 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 13f055925d..a892a03bb1 100644
--- a/lib/al/Library/Camera/CameraTargetHolder.h
+++ b/lib/al/Library/Camera/CameraTargetHolder.h
@@ -11,7 +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
     s8 hasTargetChanged = false;
 };
 
@@ -34,13 +40,14 @@ class CameraTargetHolder {
     void addPlacementSubTarget(CameraSubTargetBase* subTarget);
     void removePlacementSubTarget(CameraSubTargetBase* subTarget);
 
+    const ViewSubTargetInfo& getTopSubTargetInfo() const { return mTopSubTargetInfo; }
+
 private:
     s32 mViewTargetSize = 0;
     CameraTargetBase** mViewTargetArray = nullptr;
     ViewTargetInfo* mViewTargetInfo = nullptr;
     sead::PtrArray<CameraTargetBase> mTargetArray;
-    CameraSubTargetBase* mTopSubTarget = nullptr;
-    bool mHasTopSubTargetChanged = false;
+    ViewSubTargetInfo mTopSubTargetInfo;
     sead::PtrArray<CameraSubTargetBase> mSubTargetArray;
     sead::PtrArray<CameraSubTargetBase> 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..a112a1d2c5 100644
--- a/lib/al/Library/Camera/SnapShotCameraCtrl.h
+++ b/lib/al/Library/Camera/SnapShotCameraCtrl.h
@@ -30,7 +30,23 @@ class SnapShotCameraCtrl : public NerveExecutor, public IUseAudioKeeper {
     void exeWait();
     void exeReset();
 
-    f32 getFovyDegree() const { return mFovyDegree; };
+    AudioKeeper* getAudioKeeper() const override;
+
+    f32 getFovyDegree() const { return mFovyDegree; }
+
+    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;
@@ -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..e38703355d 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) const { return mCameraRails[index]; }
+
 private:
     s32 mCameraRailCount = 0;
     CameraLimitRailKeeper** mCameraRails = nullptr;
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 4fd012f06f..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);
@@ -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/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/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 b431b6f054..b84f8f8f1e 100644
--- a/lib/al/Project/Camera/CameraSubTargetTurnParam.h
+++ b/lib/al/Project/Camera/CameraSubTargetTurnParam.h
@@ -5,25 +5,25 @@
 namespace al {
 struct ActorInitInfo;
 
-class CameraSubTargetTurnParam {
-public:
+struct CameraSubTargetTurnParam {
     CameraSubTargetTurnParam() {}
 
     void init(const ActorInitInfo& info);
 
-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 _18 = 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