1#pragma once
2
3#include <gfx/seadCamera.h>
4#include <math/seadMatrix.h>
5#include <math/seadQuat.h>
6#include <math/seadVector.h>
7
8#include "Library/Area/IUseAreaObj.h"
9#include "Library/Audio/IUseAudioKeeper.h"
10#include "Library/Collision/IUseCollision.h"
11#include "Library/HostIO/HioNode.h"
12#include "Library/HostIO/IUseName.h"
13#include "Library/Nerve/IUseNerve.h"
14#include "Library/Projection/OrthoProjectionInfo.h"
15#include "Library/Rail/IUseRail.h"
16
17namespace al {
18class AudioDirector;
19class ByamlIter;
20class CameraAngleCtrlInfo;
21class CameraAngleSwingInfo;
22class CameraArrowCollider;
23class CameraInputHolder;
24class CameraOffsetCtrlPreset;
25class CameraParamMoveLimit;
26class CameraRequestParamHolder;
27class CameraTargetAreaLimitter;
28class CameraTargetCollideInfoHolder;
29class CameraTargetHolder;
30class CameraTurnInfo;
31class CameraVerticalAbsorber;
32class CameraViewInfo;
33class GyroCameraCtrl;
34class Nerve;
35class PlacementInfo;
36class RailKeeper;
37class SnapShotCameraCtrl;
38struct CameraFlagCtrl;
39struct CameraObjectRequestInfo;
40struct CameraPoserFlag;
41struct CameraPoserSceneInfo;
42struct CameraStartInfo;
43struct OrthoProjectionInfo;
44struct SnapShotCameraSceneInfo;
45
46class CameraPoser : public HioNode,
47 public IUseAreaObj,
48 public IUseAudioKeeper,
49 public IUseCollision,
50 public IUseName,
51 public IUseNerve,
52 public IUseRail {
53public:
54 enum class ActiveState : s32 {
55 Start = 0,
56 Active = 1,
57 End = 2,
58 };
59
60 enum class CameraInterpoleStepType : s32 {
61 Undefined = -1,
62 ByStep = 0,
63 ByCameraDistance = 1,
64 };
65
66 struct LocalInterpole {
67 inline void interpolate(sead::LookAtCamera* cam);
68
69 s32 step = -1;
70 s32 end = 0;
71 sead::Vector3f prevCameraPos = {0, 0, 0};
72 sead::Vector3f prevLookAtPos = {0, 0, 0};
73 };
74
75 static_assert(sizeof(LocalInterpole) == 0x20);
76
77 struct LookAtInterpole {
78 inline LookAtInterpole(f32 v) : _c(v) {}
79
80 sead::Vector3f lookAtPos = {0.0f, 0.0f, 0.0f};
81 f32 _c;
82 };
83
84 static_assert(sizeof(LookAtInterpole) == 0x10);
85
86 struct CameraInterpoleStep {
87 inline void load(const ByamlIter& iter);
88
89 CameraInterpoleStepType stepType = CameraInterpoleStepType::Undefined;
90 s32 stepNum = -1;
91 };
92
93 static_assert(sizeof(CameraInterpoleStep) == 0x8);
94
95 struct CameraInterpoleParam : public CameraInterpoleStep {
96 inline CameraInterpoleParam()
97 : CameraInterpoleStep({.stepType: CameraInterpoleStepType::ByCameraDistance}) {}
98
99 inline void load(const ByamlIter& iter);
100 inline void set(CameraInterpoleStepType type, s32 step, bool isInterpolate);
101
102 s8 isEaseOut = false;
103 bool isInterpolateByStep = false;
104 };
105
106 static_assert(sizeof(CameraInterpoleParam) == 0xC);
107
108 struct OrthoProjectionParam {
109 OrthoProjectionParam() {}
110
111 inline void load(const ByamlIter& iter);
112
113 bool isSetInfo = false;
114 OrthoProjectionInfo info;
115 };
116
117 static_assert(sizeof(OrthoProjectionParam) == 0xC);
118
119 CameraPoser(const char* poserName);
120 virtual AreaObjDirector* getAreaObjDirector() const override;
121
122 virtual void init() {}
123
124 virtual void initByPlacementObj(const PlacementInfo& info) {}
125
126 virtual void endInit() {}
127
128 virtual void start(const CameraStartInfo& info) {}
129
130 virtual void update() {}
131
132 virtual void end() { mActiveState = ActiveState::End; };
133
134 virtual void loadParam(const ByamlIter& iter) {}
135
136 virtual void makeLookAtCamera(sead::LookAtCamera* cam) const {}
137
138 virtual bool receiveRequestFromObject(const CameraObjectRequestInfo& info) { return false; }
139
140 virtual bool isZooming() const { return false; }
141
142 virtual bool isEnableRotateByPad() const;
143
144 virtual void startSnapShotMode() {}
145
146 virtual void endSnapShotMode() {}
147
148 virtual const char* getName() const override { return mPoserName; }
149
150 virtual CollisionDirector* getCollisionDirector() const override;
151
152 virtual NerveKeeper* getNerveKeeper() const override { return mNerveKeeper; }
153
154 virtual AudioKeeper* getAudioKeeper() const override { return mAudioKeeper; }
155
156 virtual RailRider* getRailRider() const override;
157
158 virtual void load(const ByamlIter& iter);
159 virtual void movement(); // TODO: implementation missing
160 virtual void calcCameraPose(sead::LookAtCamera* cam) const;
161
162 virtual bool requestTurnToDirection(const CameraTurnInfo* info) { return false; }
163
164 void appear(const CameraStartInfo& startInfo);
165 bool receiveRequestFromObjectCore(const CameraObjectRequestInfo& objRequestInfo);
166
167 bool isInterpoleByCameraDistance() const;
168 bool isInterpoleEaseOut() const;
169 bool isEndInterpoleByStep() const;
170 bool isFirstCalc() const;
171
172 void initNerve(const Nerve* nerve, s32 maxStates);
173 void initArrowCollider(CameraArrowCollider* arrowCollider);
174 void initAudioKeeper(const char* name);
175 void initRail(const PlacementInfo& placementInfo);
176 void initLocalInterpole();
177 void initLookAtInterpole(f32);
178 void initOrthoProjectionParam();
179 void tryInitAreaLimitter(const PlacementInfo& placementInfo);
180 bool tryCalcOrthoProjectionInfo(OrthoProjectionInfo* projectionInfo) const;
181
182 void makeLookAtCameraPrev(sead::LookAtCamera* cam) const;
183 void makeLookAtCameraPost(sead::LookAtCamera* cam) const;
184 void makeLookAtCameraLast(sead::LookAtCamera* cam) const;
185 void makeLookAtCameraCollide(sead::LookAtCamera* cam) const;
186
187 s32 getEndInterpoleStep() const;
188 s32 getInterpoleStep() const;
189 void setInterpoleStep(s32 step);
190 void setInterpoleEaseOut();
191 void resetInterpoleStep();
192
193 void startSnapShotModeCore();
194 void endSnapShotModeCore();
195
196 f32 getFovyDegree() const;
197 f32 getSceneFovyDegree() const;
198 CameraInputHolder* getInputHolder() const;
199 CameraTargetHolder* getTargetHolder() const;
200 CameraFlagCtrl* getFlagCtrl() const;
201
202 // get
203 const sead::Vector3f& getPosition() const { return mPosition; };
204
205 const sead::Vector3f& getTargetTrans() const { return mTargetTrans; };
206
207 const sead::Vector3f& getCameraUp() const { return mCameraUp; };
208
209 const sead::Matrix34f& getViewMtx() const { return mViewMtx; };
210
211 CameraViewInfo* getViewInfo() const { return mViewInfo; }
212
213 // set
214 void setPosition(const sead::Vector3f& vec) { mPosition.set(vec); };
215
216 void setTargetTrans(const sead::Vector3f& vec) { mTargetTrans.set(vec); };
217
218 void setCameraUp(const sead::Vector3f& vec) { mCameraUp.set(vec); };
219
220 void setViewMtx(const sead::Matrix34f& mtx) { mViewMtx = mtx; }
221
222 void setFovyDegree(f32 fovy) { mFovyDegree = fovy; }
223
224protected:
225 const char* mPoserName;
226 ActiveState mActiveState = ActiveState::Start;
227 sead::Vector3f mPosition = {0.0f, 0.0f, 0.0f};
228 sead::Vector3f mTargetTrans = {0.0f, 0.0f, 500.0f};
229 sead::Vector3f mCameraUp = sead::Vector3f::ey;
230 f32 mFovyDegree = 35.0f;
231 f32 _64 = -1.0f;
232 sead::Matrix34f mViewMtx = sead::Matrix34f::ident;
233 bool _98 = false;
234 CameraPoserSceneInfo* mSceneInfo = nullptr;
235 CameraViewInfo* mViewInfo = nullptr;
236 CameraPoserFlag* mPoserFlag;
237 CameraVerticalAbsorber* mVerticalAbsorber = nullptr;
238 CameraAngleCtrlInfo* mAngleCtrlInfo = nullptr;
239 CameraAngleSwingInfo* mAngleSwingInfo = nullptr;
240 CameraArrowCollider* mArrowCollider = nullptr;
241 CameraOffsetCtrlPreset* mOffsetCtrlPreset = nullptr;
242 LocalInterpole* mLocalInterpole = nullptr;
243 LookAtInterpole* mLookAtInterpole = nullptr;
244 CameraParamMoveLimit* mParamMoveLimit = nullptr;
245 CameraTargetAreaLimitter* mTargetAreaLimitter = nullptr;
246 GyroCameraCtrl* mGyroCtrl = nullptr;
247 SnapShotCameraCtrl* mSnapShotCtrl = nullptr;
248 AudioKeeper* mAudioKeeper = nullptr;
249 NerveKeeper* mNerveKeeper = nullptr;
250 RailKeeper* mRailKeeper = nullptr;
251 CameraInterpoleParam* mActiveInterpoleParam = nullptr;
252 CameraInterpoleStep* mEndInterpoleParam = nullptr;
253 OrthoProjectionParam* mOrthoProjectionParam = nullptr;
254};
255
256static_assert(sizeof(CameraPoser) == 0x140);
257
258} // namespace al
259