Library/Screen: Implement ScreenPointer (#794)

data/file_list.yml

@@ -278109,31 +278109,33 @@ Library/Screen/ScreenPointer.o:
     label:
     - _ZN2al13ScreenPointerC1ERKNS_13ActorInitInfoEPKc
     - _ZN2al13ScreenPointerC2ERKNS_13ActorInitInfoEPKc
-    status: NotDecompiled
+    status: Matching
   - offset: 0x9d4180
     size: 40
     label: _ZN2al13ScreenPointer15hitCheckSegmentERKN4sead7Vector3IfEES5_
-    status: NotDecompiled
+    status: Matching
   - offset: 0x9d41a8
     size: 32
     label: _ZN2al13ScreenPointer20hitCheckScreenCircleERKN4sead7Vector2IfEEff
-    status: NotDecompiled
+    status: Matching
   - offset: 0x9d41c8
     size: 40
     label: _ZN2al13ScreenPointer20hitCheckLayoutCircleERKN4sead7Vector2IfEEffPFiPKNS_24ScreenPointTargetHitInfoES8_E
-    status: NotDecompiled
+    status: Matching
   - offset: 0x9d41f0
     size: 620
     label: _ZN2al13ScreenPointer21recheckAndSortSegmentERKN4sead7Vector3IfEES5_
-    status: NotDecompiled
+    status: Matching
   - offset: 0x9d445c
     size: 16
     label: _ZNK2al13ScreenPointer12getHitTargetEi
-    status: NotDecompiled
+    status: Matching
   - offset: 0x9d446c
     size: 72
     label: _ZNK2al13ScreenPointer11isHitTargetEPKNS_17ScreenPointTargetE
-    status: NotDecompiled
+    status: Matching
+Library/Screen/ScreenPointerUtil.o:
+  '.text':
   - offset: 0x9d44b4
     size: 64
     label: _ZN2al24compareScreenPointTargetEPKNS_24ScreenPointTargetHitInfoES2_

lib/al/Library/LiveActor/ActorMovementFunction.cpp

@@ -14,7 +14,7 @@
 #include "Library/Math/MathUtil.h"
 #include "Library/Matrix/MatrixUtil.h"
 #include "Library/Player/PlayerUtil.h"
-#include "Library/Screen/ScreenPoint.h"
+#include "Library/Screen/ScreenPointerUtil.h"
 #include "Library/Se/SeKeeper.h"
 
 namespace al {

lib/al/Library/Screen/ScreenPoint.h

@@ -1,9 +0,0 @@
-#pragma once
-
-namespace al {
-class LiveActor;
-}  // namespace al
-
-namespace alScreenPointFunction {
-void updateScreenPointAll(al::LiveActor* actor);
-}  // namespace alScreenPointFunction

lib/al/Library/Screen/ScreenPointDirector.h

@@ -7,21 +7,26 @@ namespace al {
 class ScreenPointer;
 class ScreenPointCheckGroup;
 class ScreenPointTarget;
-class ScreenPointTargetHitInfo;
+struct ScreenPointTargetHitInfo;
 
 class ScreenPointDirector {
 public:
     ScreenPointDirector();
     void registerTarget(ScreenPointTarget*);
     void setCheckGroup(ScreenPointTarget*);
-    bool hitCheckSegment(ScreenPointer*, sead::ObjArray<ScreenPointTargetHitInfo>*, s32,
-                         const sead::Vector3f&, const sead::Vector3f&);
-    bool hitCheckScreenCircle(ScreenPointer*, sead::ObjArray<ScreenPointTargetHitInfo>*, s32,
-                              const sead::Vector2f&, f32, f32);
-    bool hitCheckLayoutCircle(ScreenPointer*, sead::ObjArray<ScreenPointTargetHitInfo>*, s32,
-                              const sead::Vector2f&, f32, f32,
-                              s32 (*)(const ScreenPointTargetHitInfo*,
-                                      const ScreenPointTargetHitInfo*));
+    bool hitCheckSegment(ScreenPointer* screenPointer,
+                         sead::ObjArray<ScreenPointTargetHitInfo>* targetHitInfo, s32 size,
+                         const sead::Vector3f& posStart, const sead::Vector3f& posEnd);
+    // TODO: Check meaning of radius and screenRadius
+    bool hitCheckScreenCircle(ScreenPointer* screenPointer,
+                              sead::ObjArray<ScreenPointTargetHitInfo>* targetHitInfo, s32 size,
+                              const sead::Vector2f& pos, f32 radius, f32 screenRadius);
+    // TODO: Check meaning of radius and screenRadius
+    bool hitCheckLayoutCircle(ScreenPointer* screenPointer,
+                              sead::ObjArray<ScreenPointTargetHitInfo>* targetHitInfo, s32 size,
+                              const sead::Vector2f& pos, f32 radius, f32 layoutRadius,
+                              s32 (*cmp)(const ScreenPointTargetHitInfo*,
+                                         const ScreenPointTargetHitInfo*));
 
 private:
     ScreenPointCheckGroup* mCheckGroup;

lib/al/Library/Screen/ScreenPointTarget.h

@@ -34,6 +34,8 @@ public:
 
     LiveActor* getActor() const { return mActor; }
 
+    const sead::Vector3f& getTargetPos() const { return mTargetPos; }
+
 private:
     void* filler;
     ParameterObj* mParameterObj;
@@ -41,7 +43,7 @@ private:
     sead::Vector3f* _38;
     sead::Matrix34f* mJointMtx;
     sead::Vector3f _48;
-    sead::Vector3f _54;
+    sead::Vector3f mTargetPos;
     LiveActor* mActor;
     ScreenPointCheckGroup* mCheckGroup;
 };

lib/al/Library/Screen/ScreenPointer.cpp

@@ -0,0 +1,80 @@
+#include "Library/Screen/ScreenPointer.h"
+
+#include "Library/LiveActor/ActorInitInfo.h"
+#include "Library/LiveActor/LiveActor.h"
+#include "Library/Math/MathUtil.h"
+#include "Library/Screen/ScreenPointDirector.h"
+#include "Library/Screen/ScreenPointTarget.h"
+#include "Library/Screen/ScreenPointerUtil.h"
+
+namespace al {
+
+ScreenPointer::ScreenPointer(const ActorInitInfo& initInfo, const char* name) {
+    mHitTargetArray.allocBuffer(0x400, nullptr);
+    mDirector = initInfo.screenPointDirector;
+}
+
+bool ScreenPointer::hitCheckSegment(const sead::Vector3f& posStart, const sead::Vector3f& posEnd) {
+    return mDirector->hitCheckSegment(this, &mHitTargetArray, 0x400, posStart, posEnd);
+}
+
+bool ScreenPointer::hitCheckScreenCircle(const sead::Vector2f& pos, f32 radius, f32 screenRadius) {
+    return mDirector->hitCheckScreenCircle(this, &mHitTargetArray, 0x400, pos, radius,
+                                           screenRadius);
+}
+
+bool ScreenPointer::hitCheckLayoutCircle(const sead::Vector2f& pos, f32 radius, f32 layoutRadius,
+                                         s32 (*cmp)(const ScreenPointTargetHitInfo*,
+                                                    const ScreenPointTargetHitInfo*)) {
+    return mDirector->hitCheckLayoutCircle(this, &mHitTargetArray, 0x400, pos, radius, layoutRadius,
+                                           cmp);
+}
+
+bool ScreenPointer::recheckAndSortSegment(const sead::Vector3f& posStart,
+                                          const sead::Vector3f& posEnd) {
+    s32 size = mHitTargetArray.size();
+    for (s32 i = 0; i < size; i++) {
+        ScreenPointTarget* target = getHitTarget(i);
+        f32 targetRadius = target->getTargetRadius();
+
+        if ((target->getTargetPos() - posStart).length() <= targetRadius)
+            continue;
+
+        sead::Vector3f segmentPointStart = sead::Vector3f::zero;
+        sead::Vector3f segmentPointEnd = sead::Vector3f::zero;
+        bool isValid =
+            checkHitSegmentSphereNearDepth(target->getTargetPos(), posStart, posEnd, targetRadius,
+                                           &segmentPointStart, &segmentPointEnd);
+
+        sead::Vector3f closestSegmentPoint;
+        calcClosestSegmentPoint(&closestSegmentPoint, posStart, posEnd, target->getTargetPos());
+
+        mHitTargetArray[i]->screenPointDistance =
+            (target->getTargetPos() - closestSegmentPoint).length() - targetRadius;
+
+        if (isValid)
+            mHitTargetArray[i]->directPointDistance = (segmentPointStart - posStart).length();
+        else
+            mHitTargetArray[i]->directPointDistance = (closestSegmentPoint - posStart).length();
+
+        mHitTargetArray[i]->segmentPointStart.set(segmentPointStart);
+        mHitTargetArray[i]->segmentPointEnd.set(segmentPointEnd);
+    }
+
+    mHitTargetArray.sort(compareScreenPointTargetPriorDirectPoint);
+    return true;
+}
+
+ScreenPointTarget* ScreenPointer::getHitTarget(s32 index) const {
+    return mHitTargetArray(index)->target;
+}
+
+bool ScreenPointer::isHitTarget(const ScreenPointTarget* target) const {
+    for (s32 i = 0; i < mHitTargetArray.size(); i++)
+        if (getHitTarget(i) == target)
+            return true;
+
+    return false;
+}
+
+}  // namespace al

lib/al/Library/Screen/ScreenPointer.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+#include <container/seadObjArray.h>
+#include <math/seadVector.h>
+
+namespace al {
+struct ActorInitInfo;
+class ScreenPointDirector;
+class ScreenPointTarget;
+
+struct ScreenPointTargetHitInfo {
+    void* _0;
+    ScreenPointTarget* target;
+    f32 screenPointDistance;
+    f32 directPointDistance;
+    sead::Vector3f segmentPointStart;
+    sead::Vector3f segmentPointEnd;
+};
+
+static_assert(sizeof(ScreenPointTargetHitInfo) == 0x30);
+
+class ScreenPointer {
+public:
+    ScreenPointer(const ActorInitInfo& initInfo, const char* name);
+
+    bool hitCheckSegment(const sead::Vector3f& posStart, const sead::Vector3f& posEnd);
+    bool hitCheckScreenCircle(const sead::Vector2f& pos, f32 radius, f32 screenRadius);
+    bool hitCheckLayoutCircle(const sead::Vector2f& pos, f32 radius, f32 layoutRadius,
+                              s32 (*cmp)(const ScreenPointTargetHitInfo*,
+                                         const ScreenPointTargetHitInfo*));
+    bool recheckAndSortSegment(const sead::Vector3f& posStart, const sead::Vector3f& posEnd);
+    ScreenPointTarget* getHitTarget(s32 index) const;
+    bool isHitTarget(const ScreenPointTarget* target) const;
+
+    s32 getHitTargetNum() const { return mHitTargetArray.size(); }
+
+private:
+    ScreenPointDirector* mDirector = nullptr;
+    sead::ObjArray<ScreenPointTargetHitInfo> mHitTargetArray;
+};
+
+static_assert(sizeof(ScreenPointer) == 0x28);
+
+}  // namespace al

lib/al/Library/Screen/ScreenPointerUtil.cpp

@@ -1,4 +1,4 @@
-#include "Library/Screen/ScreenPoint.h"
+#include "Library/Screen/ScreenPointerUtil.h"
 
 #include "Library/LiveActor/LiveActor.h"
 #include "Library/Screen/ScreenPointKeeper.h"

lib/al/Library/Screen/ScreenPointerUtil.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+#include <math/seadVector.h>
+
+namespace al {
+struct ActorInitInfo;
+class LiveActor;
+class ScreenPointer;
+class ScreenPointTarget;
+struct ScreenPointTargetHitInfo;
+class SensorMsg;
+
+s32 compareScreenPointTarget(const ScreenPointTargetHitInfo*, const ScreenPointTargetHitInfo*);
+s32 compareScreenPointTargetPriorDirectPoint(const ScreenPointTargetHitInfo*,
+                                             const ScreenPointTargetHitInfo*);
+bool isExistScreenPointTargetKeeper(LiveActor*);
+bool isScreenPointTargetArrayFull(LiveActor*);
+bool isExistScreenPointTarget(LiveActor*, const char*);
+ScreenPointTarget* addScreenPointTarget(LiveActor*, const ActorInitInfo&, const char*, f32,
+                                        const char*, const sead::Vector3f&);
+bool hitCheckSegmentScreenPointTarget(ScreenPointer*, const sead::Vector3f&, const sead::Vector3f&);
+bool hitCheckScreenCircleScreenPointTarget(ScreenPointer*, const sead::Vector2f&, f32, f32);
+bool hitCheckLayoutCircleScreenPointTarget(ScreenPointer*, const sead::Vector2f&, f32, f32,
+                                           s32 (*)(const ScreenPointTargetHitInfo*,
+                                                   const ScreenPointTargetHitInfo*));
+bool isHitScreenPointTarget(ScreenPointer*, const ScreenPointTarget*);
+bool sendMsgScreenPointTarget(const SensorMsg&, ScreenPointer*, ScreenPointTarget*);
+s32 getHitTargetNum(ScreenPointer*);
+const sead::Vector3f& getHitTargetPos(ScreenPointer*, s32);
+f32 getHitTargetRadius(ScreenPointer*, s32);
+}  // namespace al
+
+namespace alScreenPointFunction {
+void updateScreenPointAll(al::LiveActor* actor);
+}  // namespace alScreenPointFunction