Player: Implement CapTargetFunction (#901)

data/file_list.yml

@@ -112838,12 +112838,10 @@ Player/CapTargetInfo.o:
     size: 520
     label: _ZNK13CapTargetInfo27calcLockOnFollowTargetScaleEPN4sead7Vector3IfEE
     status: Matching
-Player/CapTargetInfoFunction.o:
-  '.text':
   - offset: 0x3f5f84
     size: 1004
     label: _ZN21CapTargetInfoFunction21initIterCapTargetInfoEP13CapTargetInfoP19IUsePlayerCollisionPKN2al9LiveActorEPKc
-    status: NotDecompiled
+    status: Matching
 Player/CollidedShapeResult.o:
   '.text':
   - offset: 0x3f6370

src/Player/CapTargetInfo.cpp

@@ -3,9 +3,11 @@
 #include "Library/Base/StringUtil.h"
 #include "Library/LiveActor/ActorModelFunction.h"
 #include "Library/LiveActor/ActorPoseUtil.h"
+#include "Library/LiveActor/ActorResourceFunction.h"
 #include "Library/LiveActor/LiveActor.h"
 #include "Library/Math/MathUtil.h"
 #include "Library/Matrix/MatrixUtil.h"
+#include "Library/Yaml/ByamlUtil.h"
 
 CapTargetInfo::CapTargetInfo() = default;
 
@@ -89,7 +91,7 @@ void CapTargetInfo::makeLockOnMtx(sead::Matrix34f* outMtx) const {
 
     sead::Matrix34f poseMatrix = rotationMatrix * translationMatrix;
 
-    if (mIsUseFollowScaleLocalOffset) {
+    if (mIsUseFollowMtxScaleLocalOffset) {
         sead::Matrix34f baseMtx = sead::Matrix34f::ident;
         baseMtx = *mJointMtx * rotationMatrix;
 
@@ -132,3 +134,80 @@ void CapTargetInfo::calcLockOnFollowTargetScale(sead::Vector3f* targetScale) con
     al::calcMtxScale(targetScale, baseMtx * rotationMatrix);
     *targetScale *= mLockOnScale;
 }
+
+void CapTargetInfoFunction::initIterCapTargetInfo(CapTargetInfo* capTargetInfo,
+                                                  IUsePlayerCollision* playerCollision,
+                                                  const al::LiveActor* actor, const char* name) {
+    capTargetInfo->init(actor, name);
+    capTargetInfo->mPlayerCollision = playerCollision;
+
+    al::StringTmp<256> fileName("");
+    al::createFileNameBySuffix(&fileName, "InitHackCap", name);
+    if (!al::isExistModelResourceYaml(actor, fileName.cstr(), nullptr)) {
+        al::createFileNameBySuffix(&fileName, "InitHackerCap", name);
+        if (!al::isExistModelResourceYaml(actor, fileName.cstr(), nullptr))
+            return;
+    }
+
+    const char* fileNameStr = fileName.cstr();
+    if (!fileNameStr)
+        return;
+
+    al::ByamlIter resourceYaml(al::getModelResourceYaml(actor, fileNameStr, 0));
+
+    const char* jointName = al::tryGetByamlKeyStringOrNULL(resourceYaml, "JointName");
+    sead::Vector3f localTrans = {0.0f, 0.0f, 0.0f};
+    al::tryGetByamlV3f(&localTrans, resourceYaml, "LocalTrans");
+    sead::Vector3f localRotate = {0.0f, 0.0f, 0.0f};
+    al::tryGetByamlV3f(&localRotate, resourceYaml, "LocalRotate");
+    capTargetInfo->setFollowLockOnMtx(jointName, localTrans, localRotate);
+
+    bool useLockOnFollowMtxScale = false;
+    al::tryGetByamlBool(&useLockOnFollowMtxScale, resourceYaml, "UseLockOnFollowMtxScale");
+    capTargetInfo->mIsUseLockOnFollowMtxScale = useLockOnFollowMtxScale;
+
+    bool useFollowMtxScaleLocalOffset = false;
+    al::tryGetByamlBool(&useFollowMtxScaleLocalOffset, resourceYaml,
+                        "UseFollowMtxScaleLocalOffset");
+    capTargetInfo->mIsUseFollowMtxScaleLocalOffset = useFollowMtxScaleLocalOffset;
+
+    f32 lockOnScale = 1.0f;
+    al::tryGetByamlF32(&lockOnScale, resourceYaml, "LockOnScale");
+    capTargetInfo->mLockOnScale = lockOnScale;
+
+    sead::Vector3f escapeLocalOffset = {0.0f, 0.0f, 0.0f};
+    if (al::tryGetByamlV3f(&escapeLocalOffset, resourceYaml, "EscapeLocalOffset")) {
+        capTargetInfo->mIsEscapeLocalOffset = true;
+        capTargetInfo->mEscapeLocalOffset = escapeLocalOffset;
+    }
+
+    const char* lockOnStartAnimName =
+        al::tryGetByamlKeyStringOrNULL(resourceYaml, "LockOnStartAnimName");
+    if (lockOnStartAnimName)
+        capTargetInfo->setLockOnStartAnimName(lockOnStartAnimName);
+
+    const char* lockOnAnimName = al::tryGetByamlKeyStringOrNULL(resourceYaml, "LockOnAnimName");
+    if (lockOnAnimName)
+        capTargetInfo->setLockOnAnimName(lockOnAnimName);
+
+    bool isLockOnOnly = false;
+    al::tryGetByamlBool(&isLockOnOnly, resourceYaml, "LockOnOnly");
+    capTargetInfo->mIsLockOnOnly = isLockOnOnly;
+
+    capTargetInfo->setHackName(al::tryGetByamlKeyStringOrNULL(resourceYaml, "HackName"));
+
+    bool isSetHackNameToCamera = false;
+    al::tryGetByamlBool(&isSetHackNameToCamera, resourceYaml, "IsSetHackNameToCamera");
+    capTargetInfo->mIsSetHackNameToCamera = isSetHackNameToCamera;
+
+    bool isInvalidHackThrow = false;
+    al::tryGetByamlBool(&isInvalidHackThrow, resourceYaml, "IsInvalidHackThrow");
+    capTargetInfo->mIsInvalidHackThrow = isInvalidHackThrow;
+
+    bool isInvalidCapEye = false;
+    al::tryGetByamlBool(&isInvalidCapEye, resourceYaml, "IsInvalidCapEye");
+    capTargetInfo->mIsInvalidCapEye = isInvalidCapEye;
+
+    capTargetInfo->mIsUseDepthShadow =
+        al::tryGetByamlKeyBoolOrFalse(resourceYaml, "UseDepthShadow");
+}

src/Player/CapTargetInfo.h

@@ -5,9 +5,11 @@
 
 namespace al {
 class LiveActor;
-class IUsePlayerCollision;
 }  // namespace al
 
+class IUsePlayerCollision;
+class CapTargetInfoFunction;
+
 class CapTargetInfo {
 public:
     CapTargetInfo();
@@ -24,16 +26,17 @@ public:
     void setPoseMatrix(sead::Matrix34f* mtx) { mPoseMatrix = mtx; }
 
 private:
+    friend CapTargetInfoFunction;
     const al::LiveActor* mActor = nullptr;
     const char* mHackName = nullptr;
-    al::IUsePlayerCollision* mPlayerCollision = nullptr;
+    IUsePlayerCollision* mPlayerCollision = nullptr;
     sead::Matrix34f* mPoseMatrix = nullptr;
     const sead::Matrix34f* mJointMtx = nullptr;
     sead::Vector3f mLocalTrans = sead::Vector3f::zero;
     sead::Vector3f mLocalRotate = sead::Vector3f::zero;
     f32 mLockOnScale = 1.0f;
     bool mIsUseLockOnFollowMtxScale = false;
-    bool mIsUseFollowScaleLocalOffset = false;
+    bool mIsUseFollowMtxScaleLocalOffset = false;
     const char* mLockOnStartAnimName = "Capture";
     const char* mLockOnAnimName = "Capture";
     bool mIsEscapeLocalOffset = false;
@@ -56,3 +59,9 @@ private:
     bool _7e = false;
     bool _7f = false;
 };
+
+class CapTargetInfoFunction {
+public:
+    static void initIterCapTargetInfo(CapTargetInfo* capTargetInfo, IUsePlayerCollision*,
+                                      const al::LiveActor* actor, const char* name);
+};