SMG-Decomp
A decompilation of Super Mario Galaxy 1
Loading...
Searching...
No Matches
CameraManGame.cpp
1#include "Game/AreaObj/CubeCamera.hpp"
2#include "Game/Boss/SkeletalFishGuard.hpp"
3#include "Game/Camera/Camera.hpp"
4#include "Game/Camera/Camera.hpp"
5#include "Game/Camera/CameraDirector.hpp"
6#include "Game/Camera/CameraHeightArrange.hpp"
7#include "Game/Camera/CameraHolder.hpp"
8#include "Game/Camera/CameraLocalUtil.hpp"
9#include "Game/Camera/CameraManGame.hpp"
10#include "Game/Camera/CameraParamChunk.hpp"
11#include "Game/Camera/CameraParamChunkHolder.hpp"
12#include "Game/Camera/CameraTargetObj.hpp"
13#include "Game/Camera/CamKarikariEffector.hpp"
14#include "Game/Camera/CamHeliEffector.hpp"
15#include "Game/MapObj/GCapture.hpp"
16#include <cstring>
17
18namespace {
19 const char *gDefaultCameraName = "デフォルトカメラ";
20 const char *gDefaultWaterCameraName = "デフォルト水中カメラ";
21 const char *gDefaultWaterSurfaceCameraName = "デフォルト水面カメラ";
22 const char *gDefaultFooFighterCameraName = "デフォルトフーファイターカメラ";
23 const char *gDefaultStartAnimCameraName = "スタートアニメカメラ";
24}
25
26const char *CameraParamChunk::getClassName() const {
27 return "Base";
28}
29
30bool CameraTargetObj::isWaterMode() const {
31 return false;
32}
33
34bool CameraTargetObj::isOnWaterSurface() const {
35 return false;
36}
37
38bool CameraTargetObj::isFooFighterMode() const {
39 return false;
40}
41
42CubeCameraArea *CameraTargetObj::getCubeCameraArea() const {
43 return nullptr;
44}
45
46Triangle *CameraTargetObj::getGroundTriangle() const {
47 return nullptr;
48}
49
50CameraManGame::CameraManGame(CameraHolder *pHolder, CameraParamChunkHolder *pChunkHolder, const char *pName) : CameraMan(pName) {
51 mHolder = pHolder;
52 mChunkHolder = pChunkHolder;
53 _58 = 0;
54 _5C = 0;
55 mKarikari = new CamKarikariEffector();
56 mHeli = new CamHeliEffector();
57 mTypeState = 0;
58 _6C = 0;
59 _70 = 0;
60 mZoomedIn = false;
61 mCamera = mHolder->getDefaultCamera();
62 mChunk = nullptr;
63 CameraLocalUtil::setWatchPos(this, TVec3f(0.0f, 0.0f, 300.0f));
64}
65
66CameraManGame::~CameraManGame() {
67
68}
69
70void CameraManGame::init(const JMapInfoIter &rIter) {
71
72}
73
74void CameraManGame::calc() {
75 selectCameraChunk();
76 checkReset();
77 CameraTargetObj *target = mCamera->calc();
78 CameraLocalUtil::setUsedTarget(this, target);
79 setSafePose();
80 mKarikari->update(this);
81 mHeli->update(this);
82}
83
84void CameraManGame::notifyActivate() {
85 _58 = 1;
86}
87
88void CameraManGame::notifyDeactivate() {
89
90}
91
92bool CameraManGame::isInterpolationOff() const {
93 if (mCamera != nullptr && mCamera->isInterpolationOff()) {
94 return true;
95 }
96
97 if (mChunk != nullptr && mChunk->isAntiBlurOff()) {
98 return true;
99 }
100
101 return false;
102}
103
104bool CameraManGame::isCollisionOff() const {
105 if (mCamera != nullptr && mCamera->isCollisionOff()) {
106 return true;
107 }
108
109 if (mChunk != nullptr && mChunk->isCollisionOff()) {
110 return true;
111 }
112
113 return false;
114}
115
116bool CameraManGame::isZeroFrameMoveOff() const {
117 if (mCamera != nullptr) {
118 return mCamera->isZeroFrameMoveOff();
119 }
120
121 return false;
122}
123
124bool CameraManGame::isSubjectiveCameraOff() const {
125 if (mCamera != nullptr && mCamera->isSubjectiveCameraOff()) {
126 return true;
127 }
128
129 if (mChunk != nullptr && mChunk->isSubjectiveCameraOff()) {
130 return true;
131 }
132
133 return false;
134}
135
136bool CameraManGame::isCorrectingErpPositionOff() const {
137 bool off = false;
138
139 if (mCamera != nullptr && mCamera->isCorrectingErpPositionOff()) {
140 off = true;
141 }
142
143 return off;
144}
145
146bool CameraManGame::isEnableToRoundLeft() const {
147 if (mCamera != nullptr) {
148 return mCamera->isEnableToRoundLeft();
149 }
150
151 return false;
152}
153
154bool CameraManGame::isEnableToRoundRight() const {
155 if (mCamera != nullptr) {
156 return mCamera->isEnableToRoundRight();
157 }
158
159 return false;
160}
161
162bool CameraManGame::isEnableToReset() const {
163 if (mCamera != nullptr) {
164 return mCamera->isEnableToReset();
165 }
166
167 return false;
168}
169
170void CameraManGame::closeCreatingCameraChunk() {
171 createDefaultCamera();
172 createDefaultWaterCamera();
173 createDefaultWaterSurfaceCamera();
174 createDefaultFooFighterCamera();
175 createStartAnimCamera();
176 createZoomCamera();
177}
178
179void CameraManGame::startStartPosCamera(bool a1) {
180 _6C = 1;
181 _70 = a1 ? 0 : 5;
182}
183
184void CameraManGame::endStartPosCamera() {
185 _6C = 0;
186 _70 = 0;
187}
188
189void CameraManGame::zoomIn() {
190 mZoomedIn = true;
191
192 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
193 chunkID.createOtherID(0, "ズームカメラ");
194
195 CameraParamChunk *chunk = mChunkHolder->getChunk(chunkID);
196
197 TVec3f *pos = CameraLocalUtil::getPos(this);
198 TVec3f *watchPos = CameraLocalUtil::getWatchPos(this);
199
200 f32 distance = PSVECDistance(reinterpret_cast<Vec *>(watchPos), reinterpret_cast<Vec *>(pos));
201 f32 dVar3 = JMAAsinRadian(100.0f / distance);
202 f32 var2 = 1.5f;
203 f32 var1 = dVar3 * var2;
204
205 chunk->mExParam.mFovy = (180.0f * (2 * var1)) / 3.1415927f;
206}
207
208void CameraManGame::zoomOut() {
209 mZoomedIn = false;
210}
211
212void CameraManGame::selectCameraChunk() {
213 if (!tryStartPosCamera() && !tryZoomCamera()) {
214 checkStateShift();
215
216 switch (mTypeState) {
217 case 0:
218 updateNormal();
219 break;
220 case 1:
221 updateSwim();
222 break;
223 case 2:
224 updateWaterSurface();
225 break;
226 case 3:
227 updateGCapture();
228 break;
229 case 4:
230 updateFooFighter();
231 break;
232 case 5:
233 break;
234 }
235 }
236}
237
238void CameraManGame::setChunk(const CameraParamChunkID &rChunk) {
239 CameraParamChunk *chunk = mChunkHolder->getChunk(rChunk);
240
241 if (chunk == nullptr) {
242 setNullCamera();
243 }
244 else {
245 chunk = tryToReplaceChunkToDefault(chunk);
246 requestResetIfNecessary(chunk);
247 replaceCurrentChunkAndCamera(chunk);
248 applyParameter();
249 }
250}
251
252#ifdef NON_MATCHING
253// Register mismatch, r0 used
254void CameraManGame::setNullCamera() {
255 mChunk = nullptr;
256 s32 index = mHolder->getIndexOfDefault();
257 mCamera = mHolder->getCameraInner(index);
258
259 f32 fovy = mDirector->getDefaultFovy();
260 CameraLocalUtil::setFovy(this, fovy);
261 CameraLocalUtil::setRoll(this, 0.0f);
262
263 CameraLocalUtil::setGlobalOffset(this, TVec3f(0.0f, 0.0f, 0.0f));
264 CameraLocalUtil::setLocalOffset(this, TVec3f(0.0f, 0.0f, 0.0f));
265 CameraLocalUtil::setFrontOffset(this, 0.0f);
266 CameraLocalUtil::setUpperOffset(this, 0.0f);
267
268 if (mCamera->mVPan != nullptr) {
269 mCamera->mVPan->resetParameter();
270 }
271}
272#endif
273
274CameraParamChunk *CameraManGame::tryToReplaceChunkToDefault(CameraParamChunk *pChunk) {
275 if (strcmp(pChunk->getClassName(), "Game") != 0) {
276 return pChunk;
277 }
278
279 CameraParamChunkGame *gameChunk = reinterpret_cast<CameraParamChunkGame *>(pChunk);
280
281 if (gameChunk->mThru != 1) {
282 return pChunk;
283 }
284
285 static const char *name = "デフォルトカメラ";
286
287 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
288 chunkID.createOtherID(0, name);
289
290 return mChunkHolder->getChunk(chunkID);
291}
292
293void CameraManGame::requestResetIfNecessary(CameraParamChunk *pChunk) {
294 if (isNecessaryToReset(pChunk)) {
295 _58 = 1;
296
297 if (isZoomCamera()) {
298 mDirector->setInterpolation(mChunk->mExParam.mCamInt);
299 }
300 else if (isCurrentChunkEnableEndInterp()) {
301 CameraParamChunkGame *gameChunk = reinterpret_cast<CameraParamChunkGame *>(mChunk);
302 mDirector->setInterpolation(gameChunk->mCamEndInt);
303 }
304 else {
305 mDirector->setInterpolation(pChunk->mExParam.mCamInt);
306 }
307 }
308}
309
310bool CameraManGame::isNecessaryToReset(CameraParamChunk *pChunk) const {
311 if (mChunk == pChunk) {
312 return false;
313 }
314
315 u8 cameraTypeIndex = pChunk->mCameraTypeIndex;
316
317 if (cameraTypeIndex != mHolder->getIndexOf(mCamera)) {
318 return true;
319 }
320
321 if (mChunk != nullptr && !mChunk->isOnNoReset()) {
322 return true;
323 }
324
325 if (!pChunk->isOnNoReset()) {
326 return true;
327 }
328
329 return false;
330}
331
332
333bool CameraManGame::isCurrentChunkEnableEndInterp() const {
334 bool is;
335
336 if (mChunk != nullptr) {
337 is = false;
338
339 if (strcmp(mChunk->getClassName(), "Game") == 0) {
340 CameraParamChunkGame *gameChunk = reinterpret_cast<CameraParamChunkGame *>(mChunk);
341
342 if (gameChunk->mEnableEndErpFrame != 0) {
343 is = true;
344 }
345 }
346 }
347 else {
348 is = false;
349 }
350
351 return is;
352}
353
354void CameraManGame::replaceCurrentChunkAndCamera(CameraParamChunk *pChunk) {
355 mCamera = mHolder->getCameraInner(pChunk->mCameraTypeIndex);
356 mChunk = pChunk;
357}
358
359#ifdef NON_MATCHING
360// Register mismatch, r0 used
361void CameraManGame::applyParameter() {
362 CamTranslatorBase *translator = mHolder->getTranslator(mChunk->mCameraTypeIndex);
363 translator->setParam(mChunk);
364 Camera *camera = translator->getCamera();
365
366 camera->setZoneMtx(mChunk->getZoneID());
367
368 CameraLocalUtil::setGlobalOffset(mCamera, mChunk->mExParam.mWOffset);
369
370 TVec3f *localOffset = CameraLocalUtil::getLocalOffset(this);
371 CameraLocalUtil::setLocalOffset(mCamera, *localOffset);
372 CameraLocalUtil::setFrontOffset(mCamera, mChunk->mExParam.mLOffset);
373 CameraLocalUtil::setUpperOffset(mCamera, mChunk->mExParam.mLOffsetV);
374
375 if (mChunk->isOnUseFovy()) {
376 CameraLocalUtil::setFovy(mCamera, mChunk->mExParam.mFovy);
377 }
378 else {
379 CameraLocalUtil::setFovy(mCamera, mDirector->getDefaultFovy());
380 }
381
382 if (mChunk->isLOfsErpOff()) {
383 camera->_18 = 1;
384 }
385 else {
386 camera->_18 = 0;
387 }
388
389 CameraLocalUtil::setRoll(mCamera, mChunk->mExParam.mRoll);
390
391 if (camera->mVPan != nullptr) {
392 CameraHeightArrange *vPan = camera->mVPan;
393 vPan->resetParameter();
394
395 vPan->mUpper = mChunk->mExParam.mUpper;
396 vPan->mLower = mChunk->mExParam.mLower;
397 vPan->mGndInt = mChunk->mExParam.mGndInt;
398 vPan->mUPlay = mChunk->mExParam.mUPlay;
399 vPan->mLPlay = mChunk->mExParam.mLPlay;
400 vPan->mPushDelay = mChunk->mExParam.mPushDelay;
401 vPan->mPushDelayLow = mChunk->mExParam.mPushDelayLow;
402 vPan->mUDown = mChunk->mExParam.mUDown;
403 vPan->mVPanUse = mChunk->mExParam.mVPanUse != 0;
404
405 TVec3f axis;
406 mChunk->getVPanAxis(&axis);
407
408 vPan->mVPanAxis.set(axis);
409
410 vPan->_60 = 1;
411 }
412}
413#endif
414
415void CameraManGame::checkReset() {
416 if (_58 == 0 || mChunk == nullptr || mCamera == nullptr) {
417 return;
418 }
419
420 mCamera->mCameraMan = this;
421 mCamera->reset();
422 _58 = 0;
423}
424
425void CameraManGame::setSafePose() {
426 TVec3f pos = TVec3f(*CameraLocalUtil::getPos(mCamera));
427 TVec3f watchPos = TVec3f(*CameraLocalUtil::getWatchPos(mCamera));
428 TVec3f up = TVec3f(*CameraLocalUtil::getUpVec(mCamera));
429
430 if (MR::isNan(pos) || MR::isNan(watchPos) || MR::isNan(up)) {
431 return;
432 }
433
434 keepAwayWatchPos(&watchPos, pos);
435 calcSafeUpVec(&up, pos, watchPos);
436
437 CameraLocalUtil::setPos(this, pos);
438 CameraLocalUtil::setUpVec(this, up);
439 CameraLocalUtil::setWatchPos(this, watchPos);
440
441 TVec3f *watchUp = CameraLocalUtil::getWatchUpVec(mCamera);
442 CameraLocalUtil::setWatchUpVec(this, *watchUp);
443
444 TVec3f *globalOffset = CameraLocalUtil::getGlobalOffset(mCamera);
445 CameraLocalUtil::setGlobalOffset(this, *globalOffset);
446
447 TVec3f *localOffset = CameraLocalUtil::getLocalOffset(mCamera);
448 CameraLocalUtil::setLocalOffset(this, *localOffset);
449
450 f32 fovy = CameraLocalUtil::getFovy(mCamera);
451 CameraLocalUtil::setFovy(this, fovy);
452
453 f32 roll = CameraLocalUtil::getRoll(mCamera);
454 CameraLocalUtil::setRoll(this, roll);
455}
456
457#ifdef NON_MATCHING
458// Stack issues
459void CameraManGame::keepAwayWatchPos(TVec3f *watchPos, const TVec3f &pos) {
460 TVec3f dir = *watchPos - pos;
461 float length = PSVECMag(reinterpret_cast<Vec *>(&dir));
462
463 if (length < 300.0f) {
464 if (length < 1.0f) {
465 TVec3f *currentPos = CameraLocalUtil::getPos(this);
466 TVec3f *currentWatchPos = CameraLocalUtil::getWatchPos(this);
467
468 TVec3f newWatchPos1 = pos + *currentWatchPos;
469 TVec3f newWatchPos2 = newWatchPos1 - *currentPos;
470
471 watchPos->set(newWatchPos2);
472 }
473 else {
474 float length2 = PSVECMag(reinterpret_cast<Vec *>(&dir));
475 PSVECNormalize(reinterpret_cast<Vec *>(&dir), reinterpret_cast<Vec *>(&dir));
476
477 TVec3f dirCopy = TVec3f(dir);
478 dirCopy.x *= 300.0f;
479 dirCopy.y *= 300.0f;
480 dirCopy.z *= 300.0f;
481
482 watchPos->set(pos + dirCopy);
483 }
484 }
485}
486#endif
487
488void CameraManGame::createDefaultCamera() {
489 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
490 chunkID.createOtherID(0, gDefaultCameraName);
491 mChunkHolder->createChunk(chunkID, nullptr);
492}
493
494void CameraManGame::createDefaultWaterCamera() {
495 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
496 chunkID.createOtherID(0, gDefaultWaterCameraName);
497 CameraParamChunk *chunk = mChunkHolder->createChunk(chunkID, nullptr);
498
499 chunk->setCameraType("CAM_TYPE_WATER_FOLLOW", mHolder);
500
501 TVec3f wOffset = TVec3f(0.0f, 170.0f, 0.0f);
502 chunk->mExParam.mWOffset.set(wOffset);
503 chunk->mExParam.mLOffset = 100.0f;
504 chunk->mExParam.mFovy = 45.0f;
505 chunk->mExParam.mCamInt = 120;
506 chunk->mGeneralParam->mAxis.x = 1000.0f;
507 chunk->mGeneralParam->mAxis.y = 900.0f;
508 chunk->mGeneralParam->mDist = 0.01f;
509}
510
511void CameraManGame::createDefaultWaterSurfaceCamera() {
512 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
513 chunkID.createOtherID(0, gDefaultWaterSurfaceCameraName);
514 CameraParamChunk *chunk = mChunkHolder->createChunk(chunkID, nullptr);
515
516 chunk->setCameraType("CAM_TYPE_FOLLOW", mHolder);
517
518 TVec3f wOffset = TVec3f(0.0f, 170.0f, 0.0f);
519 chunk->mExParam.mWOffset.set(wOffset);
520 chunk->mExParam.mLOffset = 100.0f;
521 chunk->mExParam.mFovy = 45.0f;
522 chunk->mExParam.mCamInt = 120;
523 chunk->mGeneralParam->mAxis.x = 900.0;
524 chunk->mGeneralParam->mAxis.y = 600.0f;
525 chunk->mGeneralParam->mAngleA = 0.174533f;
526 chunk->mGeneralParam->mAngleB = 0.349066f;
527 chunk->mGeneralParam->mDist = 0.15f;
528 chunk->mGeneralParam->mNum1 = 0;
529}
530
531void CameraManGame::createDefaultFooFighterCamera() {
532 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
533 chunkID.createOtherID(0, gDefaultFooFighterCameraName);
534 CameraParamChunk *chunk = mChunkHolder->createChunk(chunkID, nullptr);
535
536 chunk->setCameraType("CAM_TYPE_FOO_FIGHTER", mHolder);
537
538 TVec3f wOffset = TVec3f(0.0f, 170.0f, 0.0f);
539 chunk->mExParam.mWOffset.set(wOffset);
540 chunk->mExParam.mLOffset = 100.0f;
541 chunk->mExParam.mFovy = 45.0f;
542 chunk->mExParam.mCamInt = 120;
543 chunk->mGeneralParam->mAxis.x = 1200.0;
544 chunk->mGeneralParam->mAxis.y = 300.0f;
545 chunk->mGeneralParam->mDist = 0.03f;
546}
547
548void CameraManGame::createStartAnimCamera() {
549 void *data;
550 s32 size;
551 MR::getCurrentScenarioStartAnimCameraData(&data, &size);
552
553 if (size >= 0) {
554 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
555 chunkID.createOtherID(0, gDefaultStartAnimCameraName);
556 CameraParamChunk *chunk = mChunkHolder->createChunk(chunkID, nullptr);
557
558 CameraDirector *director = CameraLocalUtil::getCameraDirector();
559 chunk->setCameraType("CAM_TYPE_ANIM", director->mHolder);
560
561 chunk->mGeneralParam->mNum1 = reinterpret_cast<s32>(data);
562 chunk->_64 = true;
563 }
564}
565
566void CameraManGame::createZoomCamera() {
567 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
568 chunkID.createOtherID(0, "ズームカメラ");
569 CameraParamChunk *chunk = mChunkHolder->createChunk(chunkID, nullptr);
570
571 CameraDirector *director = CameraLocalUtil::getCameraDirector();
572 chunk->setCameraType("CAM_TYPE_EYEPOS_FIX_THERE", director->mHolder);
573
574 TVec3f wOffset = TVec3f(0.0f, 0.0f, 0.0f);
575 chunk->mExParam.mWOffset.set(wOffset);
576 chunk->mExParam.mLOffset = 0.0f;
577 chunk->mExParam.mLOffsetV = 100.0f;
578
579 chunk->setUseFovy(true);
580 chunk->setLOfsErpOff(true);
581
582 chunk->mExParam.mCamInt = 0;
583 chunk->mGeneralParam->mNum1 = 1;
584 chunk->mGeneralParam->mNum2 = 1;
585 chunk->_64 = 1;
586}
587
588void CameraManGame::checkStateShift() {
589 if (!tryShiftToGCapture() && !tryShiftToSwimOrWaterSurface() && !tryShiftToFooFighter()) {
590 mTypeState = 0;
591 }
592}
593
594bool CameraManGame::tryShiftToGCapture() {
595 bool captured = MR::isPlayerGCaptured();
596
597 if (captured) {
598 mTypeState = 3;
599 return true;
600 }
601
602 return false;
603}
604
605bool CameraManGame::tryShiftToSwimOrWaterSurface() {
606 CameraTargetObj *target = CameraLocalUtil::getTarget(this);
607
608 if (target->isWaterMode()) {
609 CameraTargetObj *target2 = CameraLocalUtil::getTarget(this);
610
611 if (target2->isOnWaterSurface()) {
612 mTypeState = 2;
613 }
614 else {
615 mTypeState = 1;
616 }
617
618 return true;
619 }
620
621 return false;
622}
623
624bool CameraManGame::tryShiftToFooFighter() {
625 CameraTargetObj *target = CameraLocalUtil::getTarget(this);
626
627 if (target->isFooFighterMode()) {
628 mTypeState = 4;
629 return true;
630 }
631
632 return false;
633}
634
635/*void CameraManGame::updateNormal() {
636 if (!setCubeChunk(CubeCameraArea::CATEGORY_UNKNOWN_0)) {
637 CameraTargetObj *target = CameraLocalUtil::getTarget(this);
638
639
640 }
641}*/
642
643void CameraManGame::updateSwim() {
644 if (!setCubeChunk(CubeCameraArea::CATEGORY_UNKNOWN_1)) {
645 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
646 chunkID.createOtherID(0, gDefaultWaterCameraName);
647
648 setChunk(chunkID);
649 }
650}
651
652void CameraManGame::updateWaterSurface() {
653 if (!setCubeChunk(CubeCameraArea::CATEGORY_UNKNOWN_2)) {
654 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
655 chunkID.createOtherID(0, gDefaultWaterSurfaceCameraName);
656
657 setChunk(chunkID);
658 }
659}
660
661void CameraManGame::updateGCapture() {
662 CubeCameraArea::setCurrentCategory(CubeCameraArea::CATEGORY_UNKNOWN_3);
663 CameraTargetObj *target = CameraLocalUtil::getTarget(this);
664 const TVec3f *position = target->getPosition();
665
666 CubeCameraArea *area = reinterpret_cast<CubeCameraArea *>(MR::getAreaObj("CubeCamera", *position));
667
668 if (area != nullptr) {
669 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
670 chunkID.createCubeID(area->mZoneID, static_cast<u16>(area->mObjArg0));
671
672 setChunk(chunkID);
673 CubeCameraArea::setCurrentCategory(CubeCameraArea::CATEGORY_UNKNOWN_0);
674 }
675 else {
676 updateNormal();
677 }
678}
679
680void CameraManGame::updateFooFighter() {
681 if (!setCubeChunk(CubeCameraArea::CATEGORY_UNKNOWN_4)) {
682 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
683 chunkID.createOtherID(0, gDefaultFooFighterCameraName);
684
685 setChunk(chunkID);
686 }
687}
688
689bool CameraManGame::setCubeChunk(CubeCameraArea::ECategory category) {
690 CubeCameraArea::setCurrentCategory(static_cast<s32>(category));
691 CameraTargetObj *target = CameraLocalUtil::getTarget(this);
692 CubeCameraArea *area = target->getCubeCameraArea();
693
694 if (area != nullptr) {
695 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
696 chunkID.createCubeID(area->mZoneID, static_cast<u16>(area->mObjArg0));
697
698 setChunk(chunkID);
699 return true;
700 }
701
702 return false;
703}
704
705bool CameraManGame::tryStartPosCamera() {
706 if (_6C == 0) {
707 return false;
708 }
709
710 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
711 u16 startCameraID = static_cast<u16>(MR::getCurrentStartCameraID());
712 s32 startZoneID = MR::getCurrentStartZoneID();
713
714 chunkID.createStartID(startZoneID, startCameraID);
715 setChunk(chunkID);
716
717 if (_70 > 5) {
718 _70 = 5;
719 }
720
721 if (_70 < 0) {
722 _70 = 0;
723 }
724
725 if (_70 > 0) {
726 mDirector->setInterpolation(0);
727 }
728
729 if (_70 > 0) {
730 _70--;
731 }
732
733 return true;
734}
735
736bool CameraManGame::tryZoomCamera() {
737 if (!mZoomedIn == 0) {
738 return false;
739 }
740
741 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
742 chunkID.createOtherID(0, "ズームカメラ");
743
744 setChunk(chunkID);
745
746 return true;
747}
748
749bool CameraManGame::isZoomCamera() const {
750 CameraParamChunkID_Tmp chunkID = CameraParamChunkID_Tmp();
751 chunkID.createOtherID(0, "ズームカメラ");
752
753 CameraParamChunk *chunk = mChunkHolder->getChunk(chunkID);
754
755 return mChunk == chunk;
756}
CameraManGame::init
virtual void init(const JMapInfoIter &)
Intializes the NameObj and can set various settings and construct necessary classes.
Definition CameraManGame.cpp:70
CameraParamChunkID_Tmp
Definition CameraDirector.hpp:36
Generated by doxygen 1.10.0