Library/Camera: Implement CameraUtil

lib/al/Library/Camera/CameraDirector.h

@@ -83,6 +83,8 @@ class CameraDirector : public HioNode, public IUseExecutor {
 
     SceneCameraCtrl* getSceneCameraCtrl() const { return mSceneCameraCtrl; }
 
+    CameraTargetHolder* getTargetHolder() const { return mTargetHolder; }
+
     CameraFlagCtrl* getFlagCtrl() const { return mFlagCtrl; }
 
 private:

lib/al/Library/Camera/CameraDistanceCurve.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+
+namespace al {
+class ByamlIter;
+struct CameraDistanceAtPoint;
+
+class CameraDistanceCurve {
+public:
+    CameraDistanceCurve(const char* name, const CameraDistanceAtPoint* points, s32 pointNum);
+
+    static const CameraDistanceCurve* getDefaultCurve();
+    static const CameraDistanceCurve* findOrDefaultCurve(const ByamlIter& iter);
+    static const CameraDistanceCurve* getRocketFlowerCurve();
+    static const CameraDistanceCurve* getGiantWanderBossCurve();
+    static const CameraDistanceCurve* getKoopaShellCurve();
+    static const CameraDistanceCurve* getTRexPatrolCurve();
+
+    f32 calcDistance(f32 rate) const;
+
+private:
+    const char* mName;
+    const CameraDistanceAtPoint* mPoints;
+    s32 mPointNum;
+};
+
+}  // namespace al

lib/al/Library/Camera/CameraFlagCtrl.h

@@ -11,7 +11,7 @@ struct CameraFlagCtrl {
     bool isSnapShotModeRunning = false;
     bool isValidCameraAreaKids = false;
     bool isSeparatePlayMode = false;
-    bool _6 = false;
+    bool isInvalidEndEntranceCamera = false;
 };
 
 }  // namespace al

lib/al/Library/Camera/CameraPoseUpdater.h

@@ -20,18 +20,42 @@ class CameraViewFlag;
 class CameraViewInfo;
 class PauseCameraCtrl;
 class Projection;
+struct CameraObjectRequestInfo;
 class SceneCameraInfo;
+class CameraTurnInfo;
 
 class CameraPoseUpdater : public NerveExecutor {
 public:
     CameraPoseUpdater(SceneCameraInfo*, s32 viewIdx);
 
     void init(const CameraParamTransfer* paramTransfer, const CameraStopJudge* stopJudge,
               const CameraStartParamCtrl* startParamCtrl);
+    f32 getNearClipDistance() const;
     void update();
     bool trySwitchCamera();
     bool isActiveInterpole() const;
     void startInterpole(s32);
+    void requestCancelInterpole();
+    bool calcCameraPoseWithoutInterpole(sead::LookAtCamera*) const;
+    void startSnapshotMode(bool);
+    void endSnapshotMode();
+    bool isSnapShotOrientationRotate90() const;
+    bool isSnapShotOrientationRotate270() const;
+    void exeActive();
+    void exeDeactive();
+    void exeStop();
+    void exePause();
+    void exeSnapShot();
+    void endSnapShot();
+    void exeSnapShotNoUpdate();
+    bool isCurrentCameraPriority(s32 priority) const;
+    bool isInvalidChangeSubjectiveCamera() const;
+    bool isCurrentCameraZooming() const;
+    bool isCurrentCameraEnableRotateByPad() const;
+    bool tryReceiveCameraRequestFromObject(const CameraObjectRequestInfo& info);
+    bool tryRequestCameraTurnToDirection(const CameraTurnInfo& info);
+
+    CameraShaker* getShaker() const { return mShaker; }
 
     void setNearClipDistance(f32 distance) { mNearClipDistance = distance; }
 

lib/al/Library/Camera/CameraPoser.h

@@ -206,6 +206,14 @@ class CameraPoser : public HioNode,
     CameraTargetHolder* getTargetHolder() const;
     CameraFlagCtrl* getFlagCtrl() const;
 
+    CameraVerticalAbsorber* getVerticalAbsorber() const { return mVerticalAbsorber; }
+
+    SnapShotCameraCtrl* getSnapShotCtrl() const { return mSnapShotCtrl; }
+
+    CameraPoserFlag* getPoserFlag() const { return mPoserFlag; }
+
+    CameraAngleSwingInfo* getAngleSwingInfo() const { return mAngleSwingInfo; }
+
     // get
     const sead::Vector3f& getEye() const { return mEye; }
 
@@ -232,6 +240,8 @@ class CameraPoser : public HioNode,
 
     void setViewMtx(const sead::Matrix34f& mtx) { mViewMtx = mtx; }
 
+    void setNearClipDistance(f32 nearClipDistance) { mNearClipDistance = nearClipDistance; }
+
     void setFovyDegree(f32 fovy) { mFovyDegree = fovy; }
 
 protected:

lib/al/Library/Camera/CameraPoserAnim.h

@@ -28,22 +28,32 @@ class CameraPoserAnim : public CameraPoser {
     bool isAnimEnd() const;
     u32 calcStepMax(const char* animName) const;
 
+    bool isPlaying() const { return mStep >= 0; }
+
+    s32 getStepMax() const { return mStepMax; }
+
+    s32 getStep() const { return mStep; }
+
+    void setRotateBaseUp() { mIsRotateBaseUp = true; }
+
+    void setBaseMtxPtr(const sead::Matrix34f* baseMtxPtr) { mBaseMtxPtr = baseMtxPtr; }
+
 private:
     Resource* mRes;
     nn::g3d::ResSceneAnim* mResFile;
     nn::g3d::CameraAnimResult* mAnimResult;
     f32 _158[10];
     const char* mPlayingAnimName;
-    f32 _188;
-    s32 _18c;
+    s32 mStepMax;
+    s32 mStep;
     f32 _190;
     f32 _194;
     f32 _198;
     f32 _19c;
-    const sead::Matrix34f* _1a0;
+    const sead::Matrix34f* mBaseMtxPtr;
     f32 _1a8;
     bool mIsHoldZoom;
-    bool _1ad;
+    bool mIsRotateBaseUp;
 };
 
 static_assert(sizeof(CameraPoserAnim) == 0x1B0);

lib/al/Library/Camera/CameraPoserFixActor.h

@@ -14,9 +14,29 @@ class CameraPoserFixActor : public CameraPoser {
     void start(const CameraStartInfo& startInfo) override;
     void update() override;
 
-private:
-    const LiveActor* _140;
-    char _148[28];
+    void setTargetActor(const LiveActor* actor) { mTargetActor = actor; }
+
+    void setOffset(const sead::Vector3f& offset) { mOffset.set(offset); }
+
+    void setDistance(f32 distance) { mDistance = distance; }
+
+    void setAngleH(f32 angleH) { mAngleH = angleH; }
+
+    void setAngleV(f32 angleV) { mAngleV = angleV; }
+
+    void set_160() { _160 = true; }
+
+    void set_161() { _161 = true; }
+
+protected:
+    const LiveActor* mTargetActor;
+    sead::Vector3f mOffset;
+    f32 mDistance;
+    f32 mAngleH;
+    f32 mAngleV;
+    bool _160;
+    bool _161;
+    u8 _162[2];
     sead::Vector3f mPreLookAtPos;
 };
 
@@ -25,6 +45,12 @@ class CameraPoserFixTalk : public CameraPoserFixActor {
     CameraPoserFixTalk(const LiveActor* actor);
 
     void start(const CameraStartInfo& startInfo) override;
+
+    void set_173(f32 distance) { _173 = distance; }
+
+private:
+    f32 _173;
+    u8 _174[4];
 };
 
 class CameraPoserFixFishing : public CameraPoserFixActor {
@@ -40,6 +66,6 @@ class CameraPoserFixFishing : public CameraPoserFixActor {
 
 static_assert(sizeof(CameraPoserFixActor) == 0x170);
 static_assert(sizeof(CameraPoserFixFishing) == 0x190);
-static_assert(sizeof(CameraPoserFixTalk) == 0x170);
+static_assert(sizeof(CameraPoserFixTalk) == 0x178);
 
 }  // namespace al

lib/al/Library/Camera/CameraPoserFixLook.h

@@ -8,15 +8,15 @@ class LiveActor;
 
 class CameraPoserFixLook : public CameraPoser {
 public:
-    CameraPoserFixLook(const LiveActor* actor);
+    CameraPoserFixLook();
 
     void init() override;
     void start(const CameraStartInfo& startInfo) override;
 
-    sead::Vector3f* get_140() { return _140; }
+    void setTransPtr(sead::Vector3f* trans) { mTrans = trans; }
 
 private:
-    sead::Vector3f* _140;
+    sead::Vector3f* mTrans;
 };
 
 static_assert(sizeof(CameraPoserFixLook) == 0x148);

lib/al/Library/Camera/CameraPoserFixPoint.h

@@ -14,10 +14,12 @@ class CameraPoserFixPoint : public CameraPoser {
     void update() override;
     void makeLookAtCamera(sead::LookAtCamera* cam) const override;
 
+    void validateUsePreCameraPos() { mIsUsePreCameraPos = true; }
+
 private:
     f32 mOffsetY;
     sead::Vector3f mCameraPos;
-    bool mIsUsePrePoserPos;
+    bool mIsUsePreCameraPos;
     bool mIsKeepDistanceFromLookAt;
     f32 mKeepDistance;
 };

lib/al/Library/Camera/CameraPoserFlag.h

@@ -12,10 +12,16 @@ struct CameraPoserFlag {
     void load(const ByamlIter& iter);
     bool isValidKeepPreSelfPoseNextCamera() const;
 
+    void validateResetPoseNextCamera() { isResetPoseNextCamera = true; }
+
+    void validateKeepPreSelfPoseNextCamera() { isOverWriteProgram = true; }
+
+    void onForceCollideAtStartInterpole() { isForceCollideAtStartInterpole = true; }
+
     bool isFirstCalc = true;
     bool isOffVerticalAbsorb = false;
     bool isInvalidCollider = true;
-    bool _3 = false;
+    bool isResetPoseNextCamera = false;
     bool isValidKeepPreSelfPoseNextCameraByParam = false;
     bool isOverWriteProgram = false;
     bool isInvalidKeepPreSelfPoseNextCameraOverWriteProgram = false;
@@ -24,7 +30,7 @@ struct CameraPoserFlag {
     bool isValidCtrlSubjective = false;
     bool isInvalidChangeSubjective = false;
     bool isInvalidCameraBlur = false;
-    bool _c = false;
+    bool isForceCollideAtStartInterpole = false;
     bool isInvalidPreCameraEndAfterInterpole = false;
     bool isStopUpdateGyro = false;
 };

lib/al/Library/Camera/CameraSubTargetBase.h

@@ -14,8 +14,10 @@ class CameraSubTargetBase : public CameraTargetBase {
     void calcFront(sead::Vector3f* front) const override;
     void calcVelocity(sead::Vector3f* velocity) const override;
 
+    void initTurnParam(const CameraSubTargetTurnParam* turnParam) { mTurnParam = turnParam; }
+
 private:
-    CameraSubTargetTurnParam* mTurnParam;
+    const CameraSubTargetTurnParam* mTurnParam;
 };
 
 static_assert(sizeof(CameraSubTargetBase) == 0x18);

lib/al/Library/Camera/CameraTargetHolder.h

@@ -34,6 +34,8 @@ class CameraTargetHolder {
     void addPlacementSubTarget(CameraSubTargetBase* subTarget);
     void removePlacementSubTarget(CameraSubTargetBase* subTarget);
 
+    void setViewTarget(CameraTargetBase* target, s32 index) { mViewTargetArray[index] = target; }
+
 private:
     s32 mViewTargetSize = 0;
     CameraTargetBase** mViewTargetArray = nullptr;

lib/al/Library/Camera/CameraTicket.h

@@ -3,6 +3,16 @@
 #include <basis/seadTypes.h>
 
 namespace al {
+class CameraPoserAnim;
+class CameraPoserCart;
+class CameraPoserEntrance;
+class CameraPoserFixActor;
+class CameraPoserFixPoint;
+class CameraPoserParallelSimple;
+class CameraPoserQuickTurn;
+class CameraPoserRace;
+class CameraPoserSubjective;
+class CameraPoserTower;
 class CameraPoser;
 class CameraTicketId;
 
@@ -28,6 +38,26 @@ class CameraTicket {
 
     CameraPoser* getPoser() const { return mPoser; }
 
+    CameraPoserAnim* getAnimPoser() const { return mAnimPoser; }
+
+    CameraPoserCart* getCartPoser() const { return mCartPoser; }
+
+    CameraPoserEntrance* getEntrancePoser() const { return mEntrancePoser; }
+
+    CameraPoserFixActor* getFixActorPoser() const { return mFixActorPoser; }
+
+    CameraPoserFixPoint* getFixPointPoser() const { return mFixPointPoser; }
+
+    CameraPoserParallelSimple* getParallelSimplePoser() const { return mParallelSimplePoser; }
+
+    CameraPoserQuickTurn* getQuickTurnPoser() const { return mQuickTurnPoser; }
+
+    CameraPoserRace* getRacePoser() const { return mRacePoser; }
+
+    CameraPoserSubjective* getSubjectivePoser() const { return mSubjectivePoser; }
+
+    CameraPoserTower* getTowerPoser() const { return mTowerPoser; }
+
     const CameraTicketId* getTicketId() const { return mTicketId; }
 
     s32 getPriority() const { return mPriority; }
@@ -37,7 +67,20 @@ class CameraTicket {
     void setActiveCamera(bool isActiveCamera) { mIsActiveCamera = isActiveCamera; }
 
 private:
-    CameraPoser* mPoser;
+    union {
+        CameraPoser* mPoser;
+        CameraPoserAnim* mAnimPoser;
+        CameraPoserCart* mCartPoser;
+        CameraPoserEntrance* mEntrancePoser;
+        CameraPoserFixActor* mFixActorPoser;
+        CameraPoserFixPoint* mFixPointPoser;
+        CameraPoserParallelSimple* mParallelSimplePoser;
+        CameraPoserQuickTurn* mQuickTurnPoser;
+        CameraPoserRace* mRacePoser;
+        CameraPoserSubjective* mSubjectivePoser;
+        CameraPoserTower* mTowerPoser;
+    };
+
     const CameraTicketId* mTicketId;
     s32 mPriority;
     bool mIsActiveCamera = false;