[Camera] Implement some CameraUtil and CameraPoserFunction

lib/al/Library/Camera/CameraPoserFunction.cpp

@@ -0,0 +1,271 @@
+#include "Library/Camera/CameraPoserFunction.h"
+
+#include "Library/Base/StringUtil.h"
+#include "Library/Camera/CameraPoser.h"
+#include "Library/Camera/CameraPoserFix.h"
+#include "Library/Camera/CameraStartInfo.h"
+#include "Library/Camera/CameraTargetBase.h"
+#include "Library/Camera/CameraTargetHolder.h"
+#include "Library/Camera/CameraViewInfo.h"
+#include "Library/Math/MathUtil.h"
+#include "Library/Projection/Projection.h"
+
+namespace alCameraPoserFunction {
+
+inline al::CameraViewInfo* getViewInfo(const al::CameraPoser* poser) {
+    return poser->getViewInfo();
+}
+
+s32 getViewIndex(const al::CameraPoser* poser) {
+    return getViewInfo(poser)->getIndex();
+}
+
+const sead::LookAtCamera& getLookAtCamera(const al::CameraPoser* poser) {
+    return getViewInfo(poser)->getLookAtCam();
+}
+
+const sead::Projection& getProjectionSead(const al::CameraPoser* poser) {
+    return getViewInfo(poser)->getProjectionSead();
+}
+
+const al::Projection* getProjection(const al::CameraPoser* poser) {
+    return &getViewInfo(poser)->getProjection();
+}
+
+const sead::Matrix44f& getProjectionMtx(const al::CameraPoser* poser) {
+    return *getViewInfo(poser)->getProjMtx();
+}
+
+f32 getNear(const al::CameraPoser* poser) {
+    return getViewInfo(poser)->getNear();
+}
+
+f32 getFar(const al::CameraPoser* poser) {
+    return getViewInfo(poser)->getFar();
+}
+
+f32 getAspect(const al::CameraPoser* poser) {
+    return getViewInfo(poser)->getAspect();
+}
+
+const sead::Vector3f& getPreCameraPos(const al::CameraPoser* poser) {
+    return getLookAtCamera(poser).getPos();
+}
+
+const sead::Vector3f& getPreLookAtPos(const al::CameraPoser* poser) {
+    return getLookAtCamera(poser).getAt();
+}
+
+const sead::Vector3f& getPreUpDir(const al::CameraPoser* poser) {
+    return getLookAtCamera(poser).getUp();
+}
+
+f32 getPreFovyDegree(const al::CameraPoser* poser) {
+    return getPreFovyRadian(poser) * 57.296f;
+}
+
+f32 getPreFovyRadian(const al::CameraPoser* poser) {
+    return getProjection(poser)->getFovy();
+}
+
+bool isPrePriorityDemo(const al::CameraStartInfo& startInfo) {
+    return startInfo.prePriorityType == al::CameraTicket::Priority_Demo;
+}
+
+bool isPrePriorityDemo2(const al::CameraStartInfo& startInfo) {
+    return startInfo.prePriorityType == al::CameraTicket::Priority_Demo2;
+}
+
+bool isPrePriorityDemoTalk(const al::CameraStartInfo& startInfo) {
+    return startInfo.prePriorityType == al::CameraTicket::Priority_DemoTalk;
+}
+
+bool isPrePriorityDemoAll(const al::CameraStartInfo& startInfo) {
+    return (startInfo.prePriorityType - al::CameraTicket::Priority_Demo) < 2;
+}
+
+bool isPrePriorityEntranceAll(const al::CameraStartInfo& startInfo) {
+    return (startInfo.prePriorityType == al::CameraTicket::Priority_Entrance) |
+           (startInfo.prePriorityType == al::CameraTicket::Priority_Unknown);
+}
+
+bool isPrePriorityPlayer(const al::CameraStartInfo& startInfo) {
+    return startInfo.prePriorityType == al::CameraTicket::Priority_Player;
+}
+
+bool isEqualPreCameraName(const al::CameraStartInfo& startInfo, const char* compareName) {
+    const char* name = startInfo.preCameraName;
+    return name && al::isEqualString(compareName, name);
+}
+
+bool isPreCameraFixAbsolute(const al::CameraStartInfo& startInfo) {
+    return isEqualPreCameraName(startInfo, al::CameraPoserFix::getFixAbsoluteCameraName());
+}
+
+bool isInvalidCollidePreCamera(const al::CameraStartInfo& startInfo) {
+    return startInfo.isInvalidCollidePreCamera;
+}
+
+bool isInvalidKeepPreCameraDistance(const al::CameraStartInfo& startInfo) {
+    return startInfo.isInvalidKeepPreCameraDistance;
+}
+
+bool isInvalidKeepPreCameraDistanceIfNoCollide(const al::CameraStartInfo& startInfo) {
+    return startInfo.isInvalidKeepPreCameraDistanceIfNoCollide;
+}
+
+bool isValidResetPreCameraPose(const al::CameraStartInfo& startInfo) {
+    return startInfo.isValidResetPreCameraPose;
+}
+
+bool isValidKeepPreSelfCameraPose(const al::CameraStartInfo& startInfo) {
+    return startInfo.isValidKeepPreSelfCameraPose;
+}
+
+f32 getPreCameraSwingAngleH(const al::CameraStartInfo& startInfo) {
+    return startInfo.preCameraSwingAngleH;
+}
+
+f32 getPreCameraSwingAngleV(const al::CameraStartInfo& startInfo) {
+    return startInfo.preCameraSwingAngleV;
+}
+
+f32 getPreCameraMaxSwingAngleH(const al::CameraStartInfo& startInfo) {
+    return startInfo.preCameraMaxSwingAngleH;
+}
+
+f32 getPreCameraMaxSwingAngleV(const al::CameraStartInfo& startInfo) {
+    return startInfo.preCameraMaxSwingAngleV;
+}
+
+bool isExistAreaAngleH(const al::CameraStartInfo& startInfo) {
+    return startInfo.isExistAreaAngleH;
+}
+
+bool isExistAreaAngleV(const al::CameraStartInfo& startInfo) {
+    return startInfo.isExistAreaAngleV;
+}
+
+f32 getAreaAngleH(const al::CameraStartInfo& startInfo) {
+    return startInfo.areaAngleH;
+}
+
+f32 getAreaAngleV(const al::CameraStartInfo& startInfo) {
+    return startInfo.areaAngleV;
+}
+
+bool isExistNextPoseByPreCamera(const al::CameraStartInfo& startInfo) {
+    return startInfo.isExistNextPoseByPreCamera;
+}
+
+f32 getNextAngleHByPreCamera(const al::CameraStartInfo& startInfo) {
+    return startInfo.nextAngleHByPreCamera;
+}
+
+f32 getNextAngleVByPreCamera(const al::CameraStartInfo& startInfo) {
+    return startInfo.nextAngleVByPreCamera;
+}
+
+void calcLookDir(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    calcCameraDir(vec, poser);
+    vec->negate();
+}
+
+void calcCameraPose(sead::Quatf* pose, const al::CameraPoser* poser) {
+    sead::Vector3f lookDir;
+    calcLookDir(&lookDir, poser);
+    al::makeQuatFrontUp(pose, lookDir, poser->getCameraUp());
+}
+
+void calcCameraDir(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    vec->setSub(poser->getPosition(), poser->getTargetTrans());
+    al::normalize(vec);
+}
+
+void calcCameraDirH(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    vec->setSub(poser->getPosition(), poser->getTargetTrans());
+    al::verticalizeVec(vec, poser->getCameraUp(), *vec);
+    al::tryNormalizeOrZero(vec);
+}
+
+void calcPreCameraDir(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    const sead::LookAtCamera* cam = &getLookAtCamera(poser);
+    vec->setSub(cam->getPos(), cam->getAt());
+    al::normalize(vec);
+}
+
+void calcPreCameraDirH(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    const sead::LookAtCamera* cam = &getLookAtCamera(poser);
+    vec->setSub(cam->getPos(), cam->getAt());
+    al::verticalizeVec(vec, sead::Vector3f::ey, *vec);
+    al::tryNormalizeOrZero(vec);
+}
+
+void calcPreLookDir(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    calcPreCameraDir(vec, poser);
+    vec->negate();
+}
+
+void calcPreLookDirH(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    const sead::LookAtCamera* cam = &getLookAtCamera(poser);
+    vec->set(cam->getAt() - cam->getPos());
+    al::verticalizeVec(vec, getLookAtCamera(poser).getUp(), *vec);
+    al::tryNormalizeOrZero(vec);
+}
+
+f32 calcPreCameraAngleH(const al::CameraPoser* poser) {
+    sead::Vector3f vec = {0, 0, 0};
+    calcPreCameraDirH(&vec, poser);
+    return atan2f(vec.x, vec.z) * 57.296f;
+}
+
+f32 calcPreCameraAngleV(const al::CameraPoser* poser) {
+    sead::Vector3f vec = {0, 0, 0};
+    calcPreCameraDir(&vec, poser);
+    al::parallelizeVec(&vec, sead::Vector3f::ey, vec);
+    return asinf(vec.length()) * 57.296f;
+}
+
+void calcTargetTrans(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcTrans(vec);
+}
+
+void setLookAtPosToTarget(al::CameraPoser* poser) {
+    sead::Vector3f vec = {0, 0, 0};
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcTrans(&vec);
+    poser->setTargetTrans(vec);
+}
+
+void setLookAtPosToTargetAddOffset(al::CameraPoser* poser, const sead::Vector3f& offset) {
+    sead::Vector3f vec = {0, 0, 0};
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcTrans(&vec);
+    poser->setTargetTrans(vec + offset);
+}
+
+void setCameraPosToTarget(al::CameraPoser* poser) {
+    sead::Vector3f vec = {0, 0, 0};
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcTrans(&vec);
+    poser->setPosition(vec);
+}
+
+void setCameraPosToTargetWithOffset(al::CameraPoser* poser, const sead::Vector3f& offset) {
+    sead::Vector3f vec = {0, 0, 0};
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcTrans(&vec);
+    poser->setPosition(vec + offset);
+}
+
+void calcTargetVelocity(sead::Vector3f* vel, const al::CameraPoser* poser) {
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcVelocity(vel);
+}
+
+void calcTargetVelocityH(sead::Vector3f* vel, const al::CameraPoser* poser) {
+    calcTargetVelocity(vel, poser);
+    sead::Vector3f up = sead::Vector3f::ey;
+    calcTargetUp(&up, poser);
+    al::verticalizeVec(vel, up, *vel);
+}
+
+void calcTargetUp(sead::Vector3f* vec, const al::CameraPoser* poser) {
+    poser->getTargetHolder()->getViewTarget(getViewIndex(poser))->calcUp(vec);
+}
+}  // namespace alCameraPoserFunction