ihateninjas/OdysseyDecomp
1
0
Fork 0
mirror of https://github.com/MonsterDruide1/OdysseyDecomp synced 2026-04-23 09:04:21 +00:00
Code Issues Actions 17 Packages Projects Releases Wiki Activity

Library/Play/Camera: Improve CameraVerticalAbsorber (#858)

Browse source
This commit is contained in:
Narr the Reg 2026-01-10 10:52:48 -06:00 committed by GitHub
parent f2ad81ece6
commit ad768fcdda
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 217 additions and 161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
data/file_list.yml
View file

@ -269832,7 +269832,7 @@ Library/Play/Camera/CameraVerticalAbsorber.o:
label:
- _ZN2al22CameraVerticalAbsorberC1EPKNS_11CameraPoserEb
- _ZN2al22CameraVerticalAbsorberC2EPKNS_11CameraPoserEb
status: NotDecompiled
status: Matching
- offset: 0x97fd34
size: 192
label: _ZN2al22CameraVerticalAbsorber4loadERKNS_9ByamlIterE
@ -269840,23 +269840,23 @@ Library/Play/Camera/CameraVerticalAbsorber.o:
- offset: 0x97fdf4
size: 376
label: _ZN2al22CameraVerticalAbsorber5startERKN4sead7Vector3IfEERKNS_15CameraStartInfoE
status: NonMatchingMajor
status: Matching
- offset: 0x97ff6c
size: 32
label: _ZNK2al22CameraVerticalAbsorber7isValidEv
status: NotDecompiled
status: Matching
- offset: 0x97ff8c
size: 856
label: _ZN2al22CameraVerticalAbsorber6updateEv
status: NonMatchingMajor
status: Matching
- offset: 0x9802e4
size: 108
label: _ZNK2al22CameraVerticalAbsorber16makeLookAtCameraEPN4sead12LookAtCameraE
status: NotDecompiled
status: Matching
- offset: 0x980350
size: 68
label: _ZN2al22CameraVerticalAbsorber14liberateAbsorbEv
status: NotDecompiled
status: Matching
- offset: 0x980394
size: 1684
label: _ZN2al22CameraVerticalAbsorber9exeAbsorbEv
@ -269884,7 +269884,7 @@ Library/Play/Camera/CameraVerticalAbsorber.o:
- offset: 0x9811b8
size: 40
label: _ZNK2al22CameraVerticalAbsorber11isAbsorbingEv
status: NotDecompiled
status: Matching
- offset: 0x9811e0
size: 80
label: _ZN2al22CameraVerticalAbsorber10invalidateEv
@ -269892,16 +269892,16 @@ Library/Play/Camera/CameraVerticalAbsorber.o:
- offset: 0x981230
size: 188
label: _ZN2al22CameraVerticalAbsorber30tryResetAbsorbVecIfInCollisionERKN4sead7Vector3IfEE
status: NotDecompiled
status: Matching
- offset: 0x9812ec
size: 68
label: _ZN2al22CameraVerticalAbsorberD2Ev
status: NotDecompiled
status: Matching
lazy: true
- offset: 0x981330
size: 76
label: _ZN2al22CameraVerticalAbsorberD0Ev
status: NotDecompiled
status: Matching
lazy: true
- offset: 0x98137c
size: 8

2
lib/al/Library/Camera/CameraPoser.h
View file

@ -209,6 +209,8 @@ public:
const sead::Matrix34f& getViewMtx() const { return mViewMtx; };
bool is_98() const { return _98; }
CameraViewInfo* getViewInfo() const { return mViewInfo; }
// set

57
lib/al/Library/Camera/CameraPoserFunction.h
View file

@ -1,12 +1,17 @@
#pragma once
#include <gfx/seadCamera.h>
#include <math/seadMatrix.h>
#include <math/seadQuat.h>
#include <math/seadVector.h>
namespace sead {
class Projection;
class LookAtCamera;
} // namespace sead
namespace al {
class CameraPoser;
class Projection;
struct CameraStartInfo;
struct CameraObjectRequestInfo;
class IUseCollision;
@ -16,19 +21,19 @@ class PlacementInfo;
namespace alCameraPoserFunction {
class CameraCollisionHitResult;
void getViewIndex(const al::CameraPoser*);
s32 getViewIndex(const al::CameraPoser*);
sead::LookAtCamera* getLookAtCamera(const al::CameraPoser*);
void getProjectionSead(const al::CameraPoser*);
void getProjection(const al::CameraPoser*);
void getProjectionMtx(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*);
void getPreUpDir(const al::CameraPoser*);
void getPreFovyDegree(const al::CameraPoser*);
void getPreFovyRadian(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&);
@ -42,21 +47,21 @@ bool isInvalidKeepPreCameraDistance(const al::CameraStartInfo&);
bool isInvalidKeepPreCameraDistanceIfNoCollide(const al::CameraStartInfo&);
bool isValidResetPreCameraPose(const al::CameraStartInfo&);
bool isValidKeepPreSelfCameraPose(const al::CameraStartInfo&);
void getPreCameraSwingAngleH(const al::CameraStartInfo&);
void getPreCameraSwingAngleV(const al::CameraStartInfo&);
void getPreCameraMaxSwingAngleH(const al::CameraStartInfo&);
void getPreCameraMaxSwingAngleV(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&);
void getAreaAngleH(const al::CameraStartInfo&);
void getAreaAngleV(const al::CameraStartInfo&);
f32 getAreaAngleH(const al::CameraStartInfo&);
f32 getAreaAngleV(const al::CameraStartInfo&);
bool isExistNextPoseByPreCamera(const al::CameraStartInfo&);
void getNextAngleHByPreCamera(const al::CameraStartInfo&);
void getNextAngleVByPreCamera(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*);
void calcCameraDirH(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*);
@ -74,21 +79,21 @@ 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*);
void calcTargetSpeedV(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*);
void calcTargetSpeedH(const al::CameraPoser*);
void calcTargetJumpSpeed(const al::CameraPoser*);
void calcTargetFallSpeed(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*);
void getUnderTargetCollisionPos(const al::CameraPoser*);
void getUnderTargetCollisionNormal(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*);
@ -193,11 +198,11 @@ bool isSceneCameraFirstCalc(const al::CameraPoser*);
bool isActiveInterpole(const al::CameraPoser*);
bool isInvalidEndEntranceCamera(const al::CameraPoser*);
bool isPause(const al::CameraPoser*);
void checkFirstCameraCollisionArrow(sead::Vector3f*, sead::Vector3f*, const al::IUseCollision*,
bool checkFirstCameraCollisionArrow(sead::Vector3f*, sead::Vector3f*, const al::IUseCollision*,
const sead::Vector3f&, const sead::Vector3f&);
void checkFirstCameraCollisionArrow(CameraCollisionHitResult*, const al::IUseCollision*,
bool checkFirstCameraCollisionArrow(CameraCollisionHitResult*, const al::IUseCollision*,
const sead::Vector3f&, const sead::Vector3f&);
void checkFirstCameraCollisionArrowOnlyCeiling(sead::Vector3f*, sead::Vector3f*,
bool checkFirstCameraCollisionArrowOnlyCeiling(sead::Vector3f*, sead::Vector3f*,
const al::IUseCollision*, const sead::Vector3f&,
const sead::Vector3f&);
void checkCameraCollisionMoveSphere(sead::Vector3f*, const al::IUseCollision*,

2
lib/al/Library/Camera/CameraStartInfo.h
View file

@ -18,7 +18,7 @@ struct CameraStartInfo {
bool isInvalidKeepPreCameraDistanceIfNoCollide;
bool isValidResetPreCameraPose;
bool isValidKeepPreSelfCameraPose;
bool isGrounded;
bool _25;
bool isExistAreaAngleH;
f32 areaAngleH;
bool isExistAreaAngleV;

227
lib/al/Library/Play/Camera/CameraVerticalAbsorber.cpp
View file

@ -1,10 +1,14 @@
#include "Library/Play/Camera/CameraVerticalAbsorber.h"
#include <gfx/seadViewport.h>
#include "Library/Camera/CameraPoser.h"
#include "Library/Camera/CameraPoserFunction.h"
#include "Library/Camera/CameraStartInfo.h"
#include "Library/Math/MathUtil.h"
#include "Library/Nerve/NerveSetupUtil.h"
#include "Library/Nerve/NerveUtil.h"
#include "Library/Screen/ScreenFunction.h"
#include "Library/Yaml/ByamlUtil.h"
namespace {
@ -22,9 +26,130 @@ NERVES_MAKE_STRUCT(CameraVerticalAbsorber, FollowGround, FollowAbsolute, FollowC
} // namespace
namespace al {
CameraVerticalAbsorber::CameraVerticalAbsorber(const CameraPoser* cameraParent,
bool isCameraPosAbsorb)
: NerveExecutor("カメラの縦パン"), mCameraPoser(cameraParent),
mIsNoCameraPosAbsorb(isCameraPosAbsorb) {
initNerve(&NrvCameraVerticalAbsorber.FollowGround);
}
void CameraVerticalAbsorber::exeFollowAbsolute() {
mTargetInterp *= 0.8f;
void CameraVerticalAbsorber::load(const ByamlIter& iter) {
ByamlIter verticalAbsorbIter;
if (!iter.tryGetIterByKey(&verticalAbsorbIter, "VerticalAbsorb"))
return;
tryGetByamlF32(&mAbsorbScreenPosUp, verticalAbsorbIter, "AbsorbScreenPosUp");
tryGetByamlF32(&mAbsorbScreenPosDown, verticalAbsorbIter, "AbsorbScreenPosDown");
tryGetByamlF32(&mHighJumpJudgeSpeedV, verticalAbsorbIter, "HighJumpJudgeSpeedV");
ByamlIter advanceAbsorbUpIter;
if (verticalAbsorbIter.tryGetIterByKey(&advanceAbsorbUpIter, "AdvanceAbsorbUp")) {
mIsAdvanceAbsorbUp = true;
mAdvanceAbsorbScreenPosUp =
getByamlKeyFloat(advanceAbsorbUpIter, "AdvanceAbsorbScreenPosUp");
}
}
void CameraVerticalAbsorber::start(const sead::Vector3f& pos, const CameraStartInfo& info) {
alCameraPoserFunction::calcTargetFront(&mPrevTargetFront, mCameraPoser);
mAbsorbVec = {0.0f, 0.0f, 0.0f};
mPrevTargetTrans.set(pos);
if (!isValid() || alCameraPoserFunction::isPlayerTypeNotTouchGround(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute);
if (alCameraPoserFunction::isTargetClimbPole(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowClimbPoleNoInterp);
if (alCameraPoserFunction::isTargetGrabCeil(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowSlow);
if (!info._25 || alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowGround);
mPrevTargetTrans.set(alCameraPoserFunction::getPreLookAtPos(mCameraPoser));
const CameraPoser* poser = mCameraPoser;
sead::Vector3f gravity = {0.0f, 0.0f, 0.0f};
alCameraPoserFunction::calcTargetGravity(&gravity, poser);
mAbsorbVec = pos - mPrevTargetTrans;
parallelizeVec(&mAbsorbVec, gravity, mAbsorbVec);
setNerve(this, &NrvCameraVerticalAbsorber.Absorb);
}
bool CameraVerticalAbsorber::isValid() const {
return !_1aa && !mIsInvalidated;
}
inline void updateAbsorbVec(sead::Vector3f* absorbVec, const CameraPoser* poser,
const sead::Vector3f& prevTrans) {
sead::Vector3f gravity = {0.0f, 0.0f, 0.0f};
alCameraPoserFunction::calcTargetGravity(&gravity, poser);
*absorbVec = poser->getTargetTrans() - prevTrans;
parallelizeVec(absorbVec, gravity, *absorbVec);
}
void CameraVerticalAbsorber::update() {
if (mIsStopUpdate)
return;
updateAbsorbVec(&mAbsorbVec, mCameraPoser, mPrevTargetTrans);
mLookAtCamera.setPos(mCameraPoser->getPosition());
mLookAtCamera.setAt(mCameraPoser->getTargetTrans());
mLookAtCamera.setUp(mCameraPoser->getCameraUp());
mLookAtCamera.normalizeUp();
makeLookAtCamera(&mLookAtCamera);
mLookAtCamera.updateViewMatrix();
mProjection.set(alCameraPoserFunction::getNear(mCameraPoser),
alCameraPoserFunction::getFar(mCameraPoser),
sead::Mathf::deg2rad(mCameraPoser->getFovyDegree()),
alCameraPoserFunction::getAspect(mCameraPoser));
alCameraPoserFunction::calcTargetFront(&mTargetFront, mCameraPoser);
if (!isNerve(this, &NrvCameraVerticalAbsorber.FollowGround) &&
alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
setNerve(this, &NrvCameraVerticalAbsorber.FollowGround);
if (!isNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute) &&
alCameraPoserFunction::isPlayerTypeNotTouchGround(mCameraPoser))
setNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute);
updateNerve();
sead::Vector3f offset = {0.0f, 0.0f, 0.0f};
if (mIsKeepInFrame) {
sead::Vector3f offsetTrans = {0.0f, 0.0f, 0.0f};
alCameraPoserFunction::calcTargetTransWithOffset(&offsetTrans, mCameraPoser);
alCameraPoserFunction::calcOffsetCameraKeepInFrameV(
&offset, &mLookAtCamera, offsetTrans, mCameraPoser, mKeepInFrameOffsetUp,
alCameraPoserFunction::isPlayerTypeHighJump(mCameraPoser) ? 300.0f :
mKeepInFrameOffsetDown);
mAbsorbVec -= offset;
}
mPrevTargetTrans.set(mCameraPoser->getTargetTrans() - mAbsorbVec);
mPrevTargetFront.set(mTargetFront);
}
void CameraVerticalAbsorber::makeLookAtCamera(sead::LookAtCamera* lookAtCamera) const {
if (!isValid())
return;
lookAtCamera->setAt(lookAtCamera->getAt() - mAbsorbVec);
if (!mIsNoCameraPosAbsorb)
lookAtCamera->setPos(lookAtCamera->getPos() - mAbsorbVec);
}
void CameraVerticalAbsorber::liberateAbsorb() {
if (isNerve(this, &NrvCameraVerticalAbsorber.Absorb))
setNerve(this, &NrvCameraVerticalAbsorber.Follow);
}
bool CameraVerticalAbsorber::isAbsorbing() const {
return isValid() && isNerve(this, &NrvCameraVerticalAbsorber.Absorb);
}
void CameraVerticalAbsorber::invalidate() {
@ -33,96 +158,20 @@ void CameraVerticalAbsorber::invalidate() {
setNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute);
}
// NON_MATCHING: https://decomp.me/scratch/Zhx9Y
void CameraVerticalAbsorber::start(const sead::Vector3f& pos, const CameraStartInfo& info) {
alCameraPoserFunction::calcTargetFront(&mPrevTargetFront, mCameraPoser);
mTargetInterp.x = 0.0f;
mTargetInterp.y = 0.0f;
mTargetInterp.z = 0.0f;
mPrevTargetTrans = pos;
if (_1aa || mIsInvalidated || alCameraPoserFunction::isPlayerTypeNotTouchGround(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute);
if (alCameraPoserFunction::isTargetClimbPole(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowClimbPoleNoInterp);
if (alCameraPoserFunction::isTargetGrabCeil(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowSlow);
if (!info.isGrounded || alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
return setNerve(this, &NrvCameraVerticalAbsorber.FollowGround);
mPrevTargetTrans = alCameraPoserFunction::getPreLookAtPos(mCameraPoser);
sead::Vector3f target;
alCameraPoserFunction::calcTargetGravity(&target, mCameraPoser);
mTargetInterp = pos - mPrevTargetTrans;
parallelizeVec(&mTargetInterp, target, mTargetInterp);
setNerve(this, &NrvCameraVerticalAbsorber.Absorb);
}
void CameraVerticalAbsorber::load(const ByamlIter& iter) {
ByamlIter it;
if (!iter.tryGetIterByKey(&it, "VerticalAbsorb"))
void CameraVerticalAbsorber::tryResetAbsorbVecIfInCollision(const sead::Vector3f& pos) {
if (!alCameraPoserFunction::checkFirstCameraCollisionArrow(nullptr, nullptr, mCameraPoser,
pos + mAbsorbVec, -mAbsorbVec))
return;
tryGetByamlF32(&mAbsorbScreenPosUp, it, "AbsorbScreenPosUp");
tryGetByamlF32(&mAbsorbScreenPosDown, it, "AbsorbScreenPosDown");
tryGetByamlF32(&mHighJumpJudgeSpeedV, it, "HighJumpJudgeSpeedV");
ByamlIter it2;
if (!it.tryGetIterByKey(&it2, "AdvanceAbsorbUp"))
return;
mIsAdvanceAbsorbUp = true;
mAdvanceAbsorbScreenPosUp = getByamlKeyFloat(it2, "AdvanceAbsorbScreenPosUp");
}
// NON_MATCHING: https://decomp.me/scratch/JdemU
void CameraVerticalAbsorber::update() {
if (mIsStopUpdate)
return;
sead::Vector3f gravity{};
alCameraPoserFunction::calcTargetGravity(&gravity, mCameraPoser);
mTargetInterp = mCameraPoser->getPosition() - mPrevTargetTrans;
parallelizeVec(&mTargetInterp, gravity, mTargetInterp);
mLookAtCamera.getPos() = mCameraPoser->getPosition();
mLookAtCamera.getAt() = mCameraPoser->getTargetTrans();
mLookAtCamera.getUp() = mCameraPoser->getCameraUp();
if (mLookAtCamera.getUp().length() > 0.0f)
mLookAtCamera.getUp().normalize();
if (!_1aa && !mIsInvalidated) {
mLookAtCamera.getAt() -= mTargetInterp;
if (!mIsNoCameraPosAbsorb)
mLookAtCamera.getPos() -= mTargetInterp;
}
mLookAtCamera.doUpdateMatrix(&mLookAtCamera.getMatrix());
mProjection.set(alCameraPoserFunction::getNear(mCameraPoser),
alCameraPoserFunction::getFar(mCameraPoser),
sead::Mathf::deg2rad(mCameraPoser->getFovyDegree()),
alCameraPoserFunction::getAspect(mCameraPoser));
alCameraPoserFunction::calcTargetFront(&mTargetFront, mCameraPoser);
if (!isNerve(this, &NrvCameraVerticalAbsorber.FollowGround) &&
alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
mAbsorbVec = {0.0f, 0.0f, 0.0f};
if (alCameraPoserFunction::isTargetCollideGround(mCameraPoser))
setNerve(this, &NrvCameraVerticalAbsorber.FollowGround);
if (!isNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute) &&
alCameraPoserFunction::isPlayerTypeNotTouchGround(mCameraPoser))
setNerve(this, &NrvCameraVerticalAbsorber.FollowAbsolute);
updateNerve();
sead::Vector3f prevTargetTrans = sead::Vector3f::zero;
if (!mIsKeepInFrame) {
prevTargetTrans = mTargetInterp;
} else {
sead::Vector3f offsetTrans = sead::Vector3f::zero;
alCameraPoserFunction::calcTargetTransWithOffset(&offsetTrans, mCameraPoser);
alCameraPoserFunction::calcOffsetCameraKeepInFrameV(
&gravity, &mLookAtCamera, offsetTrans, mCameraPoser, mKeepInFrameOffsetUp,
alCameraPoserFunction::isPlayerTypeHighJump(mCameraPoser) ? 300.0f :
mKeepInFrameOffsetDown);
prevTargetTrans = mTargetInterp - gravity;
}
mPrevTargetTrans = mCameraPoser->getTargetTrans() - prevTargetTrans;
mPrevTargetFront = mTargetFront;
else
setNerve(this, &NrvCameraVerticalAbsorber.Follow);
}
void CameraVerticalAbsorber::exeFollowAbsolute() {
mAbsorbVec *= 0.8f;
}
} // namespace al

70
lib/al/Library/Play/Camera/CameraVerticalAbsorber.h
View file

@ -3,58 +3,58 @@
#include <gfx/seadCamera.h>
#include <gfx/seadProjection.h>
#include "Library/Camera/CameraPoserFunction.h"
#include "Library/Nerve/NerveExecutor.h"
#include "Library/Yaml/ByamlIter.h"
namespace al {
class ByamlIter;
class CameraPoser;
struct CameraStartInfo;
class CameraVerticalAbsorber : public NerveExecutor {
public:
CameraVerticalAbsorber(const CameraPoser* cameraParent, bool isCameraPosAbsorb);
~CameraVerticalAbsorber();
void load(const ByamlIter& iter);
void start(const sead::Vector3f& pos, const CameraStartInfo& info);
bool isValid() const;
void update();
void makeLookAtCamera(sead::LookAtCamera* lookAtCamera) const;
void liberateAbsorb();
bool isAbsorbing() const;
void invalidate();
void tryResetAbsorbVecIfInCollision(const sead::Vector3f& pos);
void exeAbsorb();
void exeFollow();
void exeFollowAbsolute();
void exeFollowClimbPole();
void exeFollowGround();
void invalidate();
bool isAbsorbing() const;
bool isValid() const;
void liberateAbsorb();
void load(const ByamlIter& iter);
void makeLookAtCamera(sead::LookAtCamera*) const;
void start(const sead::Vector3f& pos, const CameraStartInfo& info);
void tryResetAbsorbVecIfInCollision(const sead::Vector3f&);
void update();
void exeFollowClimbPole();
void exeFollowAbsolute();
private:
const CameraPoser* mCameraPoser;
sead::LookAtCamera mLookAtCamera;
sead::PerspectiveProjection mProjection;
sead::Vector3f mTargetInterp;
f32 mLerp1;
f32 mAbsorbScreenPosUp;
f32 mAbsorbScreenPosDown;
bool mIsAdvanceAbsorbUp;
f32 mAdvanceAbsorbScreenPosUp;
bool mIsExistCollisionUnderTarget;
sead::Vector3f mUnderTargetCollisionPos;
sead::Vector3f mUnderTargetCollisionNormal;
f32 mLerp2;
f32 mKeepInFrameOffsetUp;
f32 mKeepInFrameOffsetDown;
f32 mHighJumpJudgeSpeedV;
sead::Vector3f mPrevTargetTrans;
sead::Vector3f mTargetFront;
sead::Vector3f mPrevTargetFront;
bool mIsNoCameraPosAbsorb;
bool mIsInvalidated;
bool _1aa;
bool mIsStopUpdate;
bool mIsKeepInFrame;
sead::Vector3f mAbsorbVec = {0.0f, 0.0f, 0.0f};
f32 mLerp1 = 0.0f;
f32 mAbsorbScreenPosUp = -200.0f;
f32 mAbsorbScreenPosDown = 480.0f;
bool mIsAdvanceAbsorbUp = false;
f32 mAdvanceAbsorbScreenPosUp = 0.0f;
bool mIsExistCollisionUnderTarget = false;
sead::Vector3f mUnderTargetCollisionPos = {0.0f, 0.0f, 0.0f};
sead::Vector3f mUnderTargetCollisionNormal = {0.0f, 0.0f, 0.0f};
f32 mLerp2 = 0.0f;
f32 mKeepInFrameOffsetUp = 0.0f;
f32 mKeepInFrameOffsetDown = 0.0f;
f32 mHighJumpJudgeSpeedV = 35.0f;
sead::Vector3f mPrevTargetTrans = {0.0f, 0.0f, 0.0f};
sead::Vector3f mTargetFront = sead::Vector3f::ez;
sead::Vector3f mPrevTargetFront = sead::Vector3f::ez;
bool mIsNoCameraPosAbsorb = false;
bool mIsInvalidated = false;
bool _1aa = false;
bool mIsStopUpdate = false;
bool mIsKeepInFrame = false;
};
static_assert(sizeof(CameraVerticalAbsorber) == 0x1B0);