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

Work on al::SnapShotCameraCtrl

Browse source
This commit is contained in:
GRAnimated 2025-02-10 17:48:30 -05:00
parent b6910517bb
commit 987f72af91
3 changed files with 249 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
data/odyssey_functions.csv
View file

@ -52020,18 +52020,18 @@ Address,Quality,Size,Name
0x00000071008400b8,O,000008,_ZNK2al12ICameraInput22isHoldSnapShotRollLeftEv
0x00000071008400c0,O,000008,_ZNK2al12ICameraInput23isHoldSnapShotRollRightEv
0x00000071008400c8,O,000088,_ZNK2al12ICameraInput12calcGyroPoseEPN4sead7Vector3IfEES4_S4_
0x0000007100840120,U,000172,_ZN2al18SnapShotCameraCtrlC1EPKNS_23SnapShotCameraSceneInfoE
0x00000071008401cc,U,000032,_ZN2al18SnapShotCameraCtrl5startEf
0x0000007100840120,W,000172,_ZN2al18SnapShotCameraCtrlC2EPKNS_23SnapShotCameraSceneInfoE
0x00000071008401cc,O,000032,_ZN2al18SnapShotCameraCtrl5startEf
0x00000071008401ec,O,000136,_ZN2al18SnapShotCameraCtrl4loadERKNS_9ByamlIterE
0x0000007100840274,U,000032,_ZN2al18SnapShotCameraCtrl10startResetEi
0x0000007100840294,U,001488,_ZN2al18SnapShotCameraCtrl6updateERKN4sead12LookAtCameraEPKNS_13IUseCollisionEPKNS_12ICameraInputE
0x0000007100840864,U,000088,_ZNK2al18SnapShotCameraCtrl20makeLookAtCameraPostEPN4sead12LookAtCameraE
0x00000071008408bc,U,000252,_ZNK2al18SnapShotCameraCtrl20makeLookAtCameraLastEPN4sead12LookAtCameraE
0x00000071008409b8,U,000004,_ZN2al18SnapShotCameraCtrl7exeWaitEv
0x00000071008409bc,U,000280,_ZN2al18SnapShotCameraCtrl8exeResetEv
0x0000007100840274,M,000032,_ZN2al18SnapShotCameraCtrl10startResetEi
0x0000007100840294,W,001488,_ZN2al18SnapShotCameraCtrl6updateERKN4sead12LookAtCameraEPKNS_13IUseCollisionEPKNS_12ICameraInputE
0x0000007100840864,O,000088,_ZNK2al18SnapShotCameraCtrl20makeLookAtCameraPostEPN4sead12LookAtCameraE
0x00000071008408bc,O,000252,_ZNK2al18SnapShotCameraCtrl20makeLookAtCameraLastEPN4sead12LookAtCameraE
0x00000071008409b8,O,000004,_ZN2al18SnapShotCameraCtrl7exeWaitEv
0x00000071008409bc,W,000280,_ZN2al18SnapShotCameraCtrl8exeResetEv
0x0000007100840ad4,U,000036,_ZNK2al18SnapShotCameraCtrl14getAudioKeeperEv
0x0000007100840af8,U,000036,_ZThn16_NK2al18SnapShotCameraCtrl14getAudioKeeperEv
0x0000007100840b1c,U,000036,_ZN2al18SnapShotCameraCtrlD0Ev
0x0000007100840b1c,O,000036,_ZN2al18SnapShotCameraCtrlD0Ev
0x0000007100840b40,U,000004,
0x0000007100840b44,U,000008,
0x0000007100840b4c,O,000008,_ZN2al19SpecialCameraHolderC2Ev

Can't render this file because it is too large.

213
lib/al/Library/Camera/SnapShotCameraCtrl.cpp
View file

@ -1,9 +1,49 @@
#include "Library/Camera/SnapShotCameraCtrl.h"
#include "Library/Camera/CameraPoserFunction.h"
#include "Library/Camera/ICameraInput.h"
#include "Library/Math/MathUtil.h"
#include "Library/Nerve/NerveExecutor.h"
#include "Library/Nerve/NerveUtil.h"
#include "Library/Se/SeFunction.h"
#include "Library/Yaml/ByamlUtil.h"
#include "Library/Nerve/NerveSetupUtil.h"
#include "math/seadVectorFwd.h"
namespace {
using namespace al;
NERVE_IMPL(SnapShotCameraCtrl, Wait);
NERVE_IMPL(SnapShotCameraCtrl, Reset);
NERVES_MAKE_STRUCT(SnapShotCameraCtrl, Wait, Reset);
} // namespace
namespace al {
// NON_MATCHING: also this is generating C2 when the original is C1
SnapShotCameraCtrl::SnapShotCameraCtrl(const SnapShotCameraSceneInfo* sceneInfo)
: NerveExecutor("スナップショットモード中のカメラ制御"), mCameraSceneInfo(sceneInfo) {
initNerve(&NrvSnapShotCameraCtrl.Wait, 0);
CameraParam* param = new CameraParam();
param->mHasMin = false;
param->mHasMax = false;
param->mMinFovyDegree = 40.0f;
param->mMaxFovyDegree = 85.0f;
mParam = param;
}
void SnapShotCameraCtrl::start(f32 fovy) {
field_38 = sead::Vector3f(0.0f, 0.0f, 0.0f);
mLookAtOffset = sead::Vector3f(0.0f, 0.0f, 0.0f);
mFovyDegree = fovy;
field_4C = fovy;
field_50 = fovy;
mRollDegree = 0.0f;
mRollTarget = 0.0f;
}
void SnapShotCameraCtrl::load(const ByamlIter& iter) {
CameraParam* param = mParam;
ByamlIter paramIter;
@ -15,4 +55,177 @@ void SnapShotCameraCtrl::load(const ByamlIter& iter) {
param->mHasMax = true;
}
// NON_MATCHING
void SnapShotCameraCtrl::startReset(s32 unk) {
field_64 = unk < 0 ? 15 : unk;
setNerve(this, &NrvSnapShotCameraCtrl.Reset);
}
void SnapShotCameraCtrl::update(const sead::LookAtCamera& camera, const IUseCollision* collision,
const ICameraInput* input) {
updateNerve();
if (!al::isNerve(this, &NrvSnapShotCameraCtrl.Wait))
return;
if (mIsValidZoomFovy) {
f32 prevFovyDegree = mFovyDegree;
f32 v11 = field_50;
if (input->isHoldSnapShotZoomIn())
v11 -= 3.0f;
else if (input->isHoldSnapShotZoomOut())
v11 += 3.0f;
f32 min = mParam->mHasMin ? mParam->mMinFovyDegree : 5.0f;
f32 max = mParam->mHasMax ? mParam->mMaxFovyDegree :
mMaxZoomOutFovyDegree >= 0.0f ? mMaxZoomOutFovyDegree :
field_4C;
field_50 = al::lerpValue(v11, sead::Mathf::clamp(v11, min, max), 0.3f);
mFovyDegree = al::lerpValue(mFovyDegree, field_50, 0.3f);
if (getAudioKeeper()) {
f32 v21 = mFovyDegree - prevFovyDegree;
if (mFovyDegree - prevFovyDegree <= 0.0f)
v21 = -(mFovyDegree - prevFovyDegree);
if (v21 > 0.5f)
al::holdSeWithParam(this, "Zoom", mFovyDegree, nullptr);
}
}
if (mIsValidRoll) {
f32 prevRollDegree = mRollDegree;
f32 prevRollTarget = mRollTarget;
f32 add;
if (input->isHoldSnapShotRollLeft())
add = -3.0f;
else if (input->isHoldSnapShotRollRight())
add = 3.0f;
prevRollTarget = prevRollTarget + add;
f32 v26 = -90.0f;
if (prevRollTarget >= -90.0f) {
v26 = prevRollTarget;
if (prevRollTarget > 90.0f)
v26 = 90.0f;
}
f32 v27 = al::lerpValue(mRollTarget, v26, 0.2f);
mRollTarget = v27;
f32 v29 = al::lerpValue(mRollDegree, v27, 0.15f);
mRollDegree = v29;
if (getAudioKeeper()) {
f32 v21 = mRollDegree - prevRollDegree;
if (mRollDegree - prevRollDegree <= 0.0f)
v21 = -(mRollDegree - prevRollDegree);
if (v21 > 0.2f)
al::holdSeWithParam(this, "Roll", mRollDegree, nullptr);
}
}
if (mIsValidLookAtOffset) {
sead::Vector2f moveStick = sead::Vector2f(0.0f, 0.0f);
if (input->tryCalcSnapShotMoveStick(&moveStick) && !al::isNearZero(moveStick, 0.001f)) {
sead::Vector3f forward = camera.getAt() - camera.getPos();
al::normalize(&forward);
sead::Vector3f up = camera.getUp();
al::rotateVectorDegree(&up, up, forward, mRollDegree);
al::normalize(&up);
sead::Vector3f v38;
sead::Vector3f offset;
if (al::isNearZero(moveStick.x, 0.001f)) {
v38 = sead::Vector3f(0.0f, 0.0f, 0.0f);
} else {
v38.z =
(float)((float)((float)((float)(forward.y * up.z) - (float)(forward.z * up.y)) *
moveStick.x) *
50.0f) +
0.0f;
v38.y = (float)((float)(moveStick.x * (float)((float)(forward.z * up.x) -
(float)(up.z * forward.x))) *
50.0f) +
0.0f;
v38.x = (float)((float)(moveStick.x * (float)((float)(up.y * forward.x) -
(float)(forward.y * up.x))) *
50.0f) +
0.0f;
offset = v38;
}
if (!al::isNearZero(moveStick.y, 0.001f))
offset = moveStick.y * up * 50.0f + v38;
if (!al::isNearZero(offset, 0.001f)) {
sead::Vector3f clampedOffset = mLookAtOffset + offset;
al::clampV3f(&clampedOffset, sead::Vector3f(-500.0f, -500.0f, -500.0f),
sead::Vector3f(500.0f, 500.0f, 500.0f));
al::lerpVec(&field_38, field_38, clampedOffset, 0.3f);
}
if (mCameraSceneInfo->field_8) {
if (field_38.y < 0.0f) {
f32 v46 = camera.getAt().y;
f32 v47 = mCameraSceneInfo->field_C;
if (field_38.y + camera.getAt().y < v47) {
f32 v48;
if (v47 >= v46)
v48 = camera.getAt().y;
else
v48 = mCameraSceneInfo->field_C;
field_38.y = v48 - v46;
}
}
}
sead::Vector3f newAt = camera.getAt() + field_38;
alCameraPoserFunction::checkCameraCollisionMoveSphere(&newAt, collision, newAt, newAt,
75.0f);
field_38 = newAt - camera.getAt();
}
al::lerpVec(&mLookAtOffset, mLookAtOffset, field_38, 0.3f);
}
if (unk5 && input->isTriggerReset()) { // startReset()?
field_64 = 15;
al::setNerve(this, &NrvSnapShotCameraCtrl.Reset);
}
}
void SnapShotCameraCtrl::makeLookAtCameraPost(sead::LookAtCamera* camera) const {
if (mIsValidLookAtOffset) {
camera->getAt() = camera->getAt() + mLookAtOffset;
camera->getPos() = camera->getPos() + mLookAtOffset;
}
}
void SnapShotCameraCtrl::makeLookAtCameraLast(sead::LookAtCamera* camera) const {
if (mIsValidRoll) {
sead::Vector3f v13 = camera->getAt() - camera->getPos();
al::normalize(&v13);
sead::Vector3f up = camera->getUp();
al::rotateVectorDegree(&up, up, v13, this->mRollDegree);
al::normalize(&up);
camera->getUp() = up;
camera->getUp().normalize();
}
}
void SnapShotCameraCtrl::exeWait() {}
// NON_MATCHING
void SnapShotCameraCtrl::exeReset() {
if (al::isFirstStep(this)) {
field_50 = mFovyDegree;
mRollTarget = mRollDegree;
field_38 = mLookAtOffset;
}
mFovyDegree = al::calcNerveValue(this, field_64, mFovyDegree, field_4C);
f32 rate = al::calcNerveRate(this, field_64);
rate = 1.0f - rate;
mRollDegree = mRollTarget * rate;
mLookAtOffset = rate * field_38;
if (al::isGreaterEqualStep(this, field_64)) {
field_64 = -1;
start(field_4C);
setNerve(this, &NrvSnapShotCameraCtrl.Wait);
}
}
} // namespace al

50
lib/al/Library/Camera/SnapShotCameraCtrl.h
View file

@ -6,20 +6,24 @@
#include "Library/Nerve/NerveExecutor.h"
#include "Library/Yaml/ByamlIter.h"
struct CameraParam {
bool mHasMin;
bool mHasMax;
f32 mMinFovyDegree;
f32 mMaxFovyDegree;
};
namespace al {
class SnapShotCameraSceneInfo;
struct SnapShotCameraSceneInfo {
void* unk;
bool field_8;
f32 field_C;
};
class ICameraInput;
class IUseCollision;
class SnapShotCameraCtrl : public NerveExecutor, public IUseAudioKeeper {
public:
struct CameraParam {
bool mHasMin;
bool mHasMax;
f32 mMinFovyDegree;
f32 mMaxFovyDegree;
};
SnapShotCameraCtrl(const SnapShotCameraSceneInfo*);
void start(f32);
void load(const ByamlIter&);
@ -33,20 +37,20 @@ public:
f32 getFovyDegree() const { return mFovyDegree; };
private:
SnapShotCameraSceneInfo* mCameraSceneInfo;
CameraParam* mParam;
bool mIsValidLookAtOffset;
sead::Vector3f mLookAtOffset;
sead::Vector3f unk1;
bool mIsValidZoomFovy;
f32 mFovyDegree;
f32 unk2;
f32 unk3;
f32 mMaxZoomOutFovyDegree;
bool mIsValidRoll;
f32 mRollDegree;
f32 mRollTarget;
u32 unk4;
bool unk5;
const SnapShotCameraSceneInfo* mCameraSceneInfo = nullptr;
CameraParam* mParam = nullptr;
bool mIsValidLookAtOffset = false;
sead::Vector3f mLookAtOffset = sead::Vector3f(0.0f, 0.0f, 0.0f);
sead::Vector3f field_38 = sead::Vector3f(0.0f, 0.0f, 0.0f);
bool mIsValidZoomFovy = false;
f32 mFovyDegree = 0.0f;
f32 field_4C = 0.0f;
f32 field_50 = 0.0f;
f32 mMaxZoomOutFovyDegree = -1.0f;
bool mIsValidRoll = false;
f32 mRollDegree = false;
f32 mRollTarget = false;
u32 field_64 = -1;
bool unk5 = false;
};
} // namespace al