add the grab/touch state update events

2023-05-08 11:58:22 +02:00
parent e8b586d6ab
commit 20b81712b5
4 changed files with 393 additions and 182 deletions
@@ -507,15 +507,17 @@ void ASGPawn::OnLeftThumbFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorLeftThumbCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(HandLeft, ActorLeftThumbCanGrab, ActorLeftIndexCanGrab, ActorLeftMiddleCanGrab);
    }
 }

@@ -525,13 +527,15 @@ void ASGPawn::OnLeftThumbFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftThumbCanGrab == OtherActor)
    {
        ActorLeftThumbCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(HandLeft, ActorLeftThumbCanGrab, ActorLeftIndexCanGrab, ActorLeftMiddleCanGrab);
    }
 }

@@ -543,15 +547,17 @@ void ASGPawn::OnLeftIndexFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorLeftIndexCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(HandLeft, ActorLeftThumbCanGrab, ActorLeftIndexCanGrab, ActorLeftMiddleCanGrab);
    }
 }

@@ -561,13 +567,15 @@ void ASGPawn::OnLeftIndexFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftIndexCanGrab == OtherActor)
    {
        ActorLeftIndexCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(HandLeft, ActorLeftThumbCanGrab, ActorLeftIndexCanGrab, ActorLeftMiddleCanGrab);
    }
 }

@@ -579,15 +587,17 @@ void ASGPawn::OnLeftMiddleFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorLeftMiddleCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(HandLeft, ActorLeftThumbCanGrab, ActorLeftIndexCanGrab, ActorLeftMiddleCanGrab);
    }
 }

@@ -597,13 +607,15 @@ void ASGPawn::OnLeftMiddleFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftMiddleCanGrab == OtherActor)
    {
        ActorLeftMiddleCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(HandLeft, ActorLeftThumbCanGrab, ActorLeftIndexCanGrab, ActorLeftMiddleCanGrab);
    }
 }

@@ -615,15 +627,19 @@ void ASGPawn::OnLeftThumbFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorLeftThumbTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -633,13 +649,17 @@ void ASGPawn::OnLeftThumbFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftThumbTouching == OtherActor)
    {
        ActorLeftThumbTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -651,15 +671,19 @@ void ASGPawn::OnLeftIndexFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorLeftIndexTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -669,13 +693,17 @@ void ASGPawn::OnLeftIndexFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftIndexTouching == OtherActor)
    {
        ActorLeftIndexTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -687,15 +715,19 @@ void ASGPawn::OnLeftMiddleFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorLeftMiddleTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -705,13 +737,17 @@ void ASGPawn::OnLeftMiddleFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftMiddleTouching == OtherActor)
    {
        ActorLeftMiddleTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -723,15 +759,19 @@ void ASGPawn::OnLeftRingFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorLeftRingTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -741,13 +781,17 @@ void ASGPawn::OnLeftRingFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftRingTouching == OtherActor)
    {
        ActorLeftRingTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -759,15 +803,19 @@ void ASGPawn::OnLeftPinkyFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorLeftPinkyTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -777,13 +825,17 @@ void ASGPawn::OnLeftPinkyFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorLeftPinkyTouching == OtherActor)
    {
        ActorLeftPinkyTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandLeft, ActorLeftThumbTouching, ActorLeftIndexTouching, ActorLeftMiddleTouching,
+            ActorLeftRingTouching, ActorLeftPinkyTouching);
    }
 }

@@ -795,15 +847,18 @@ void ASGPawn::OnRightThumbFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorRightThumbCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbCanGrab, ActorRightIndexCanGrab, ActorRightMiddleCanGrab);
    }
 }

@@ -813,13 +868,16 @@ void ASGPawn::OnRightThumbFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightThumbCanGrab == OtherActor)
    {
        ActorRightThumbCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbCanGrab, ActorRightIndexCanGrab, ActorRightMiddleCanGrab);
    }
 }

@@ -831,15 +889,18 @@ void ASGPawn::OnRightIndexFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorRightIndexCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbCanGrab, ActorRightIndexCanGrab, ActorRightMiddleCanGrab);
    }
 }

@@ -849,13 +910,16 @@ void ASGPawn::OnRightIndexFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightThumbCanGrab == OtherActor)
    {
        ActorRightIndexCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbCanGrab, ActorRightIndexCanGrab, ActorRightMiddleCanGrab);
    }
 }

@@ -867,15 +931,18 @@ void ASGPawn::OnRightMiddleFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorRightMiddleCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbCanGrab, ActorRightIndexCanGrab, ActorRightMiddleCanGrab);
    }
 }

@@ -885,13 +952,16 @@ void ASGPawn::OnRightMiddleFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightMiddleCanGrab == OtherActor)
    {
        ActorRightMiddleCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbCanGrab, ActorRightIndexCanGrab, ActorRightMiddleCanGrab);
    }
 }

@@ -903,15 +973,19 @@ void ASGPawn::OnRightThumbFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorRightThumbTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -921,13 +995,17 @@ void ASGPawn::OnRightThumbFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightThumbTouching == OtherActor)
    {
        ActorRightThumbTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -939,15 +1017,19 @@ void ASGPawn::OnRightIndexFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorRightIndexTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -957,13 +1039,17 @@ void ASGPawn::OnRightIndexFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightIndexTouching == OtherActor)
    {
        ActorRightIndexTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -975,15 +1061,19 @@ void ASGPawn::OnRightMiddleFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorRightMiddleTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -993,13 +1083,17 @@ void ASGPawn::OnRightMiddleFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightMiddleTouching == OtherActor)
    {
        ActorRightMiddleTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -1011,15 +1105,19 @@ void ASGPawn::OnRightRingFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorRightRingTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -1029,13 +1127,17 @@ void ASGPawn::OnRightRingFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightRingTouching == OtherActor)
    {
        ActorRightRingTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -1047,15 +1149,19 @@ void ASGPawn::OnRightPinkyFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorRightPinkyTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -1065,13 +1171,17 @@ void ASGPawn::OnRightPinkyFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRightPinkyTouching == OtherActor)
    {
        ActorRightPinkyTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            HandRight, ActorRightThumbTouching, ActorRightIndexTouching, ActorRightMiddleTouching,
+            ActorRightRingTouching, ActorRightPinkyTouching);
    }
 }

@@ -306,15 +306,17 @@ void ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorThumbCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(VirtualHand, ActorThumbCanGrab, ActorIndexCanGrab, ActorMiddleCanGrab);
    }
 }

@@ -324,13 +326,15 @@ void ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorThumbCanGrab == OtherActor)
    {
        ActorThumbCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(VirtualHand, ActorThumbCanGrab, ActorIndexCanGrab, ActorMiddleCanGrab);
    }
 }

@@ -342,15 +346,17 @@ void ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorIndexCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(VirtualHand, ActorThumbCanGrab, ActorIndexCanGrab, ActorMiddleCanGrab);
    }
 }

@@ -360,13 +366,15 @@ void ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorIndexCanGrab == OtherActor)
    {
        ActorIndexCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(VirtualHand, ActorThumbCanGrab, ActorIndexCanGrab, ActorMiddleCanGrab);
    }
 }

@@ -378,15 +386,17 @@ void ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGGrabComponent::IsGrabbable(OtherActor))
    {
        ActorMiddleCanGrab = OtherActor;
+
+        GrabStateUpdatedEvent.Broadcast(VirtualHand, ActorThumbCanGrab, ActorIndexCanGrab, ActorMiddleCanGrab);
    }
 }

@@ -396,13 +406,15 @@ void ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorMiddleCanGrab == OtherActor)
    {
        ActorMiddleCanGrab = nullptr;
+
+        GrabStateUpdatedEvent.Broadcast(VirtualHand, ActorThumbCanGrab, ActorIndexCanGrab, ActorMiddleCanGrab);
    }
 }

@@ -414,15 +426,19 @@ void ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorThumbTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -432,13 +448,17 @@ void ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorThumbTouching == OtherActor)
    {
        ActorThumbTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -450,15 +470,19 @@ void ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorIndexTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -468,13 +492,17 @@ void ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorIndexTouching == OtherActor)
    {
        ActorIndexTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -486,15 +514,19 @@ void ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapBegins(
    const bool bFromSweep,
    const FHitResult& SweepResult)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
-    (void)bFromSweep;
-    (void)SweepResult;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;
+    (void) bFromSweep;
+    (void) SweepResult;

    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorMiddleTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -504,13 +536,17 @@ void ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorMiddleTouching == OtherActor)
    {
        ActorMiddleTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -525,6 +561,10 @@ void ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapBegins(
    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorRingTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -534,13 +574,17 @@ void ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorRingTouching == OtherActor)
    {
        ActorRingTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -555,6 +599,10 @@ void ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapBegins(
    if (USGTouchComponent::IsTouchable(OtherActor))
    {
        ActorPinkyTouching = OtherActor;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -564,13 +612,17 @@ void ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapEnds(
    UPrimitiveComponent* OtherComp,
    const int32 OtherBodyIndex)
 {
-    (void)OverlappedComponent;
-    (void)OtherComp;
-    (void)OtherBodyIndex;
+    (void) OverlappedComponent;
+    (void) OtherComp;
+    (void) OtherBodyIndex;

    if (ActorPinkyTouching == OtherActor)
    {
        ActorPinkyTouching = nullptr;
+
+        TouchStateUpdatedEvent.Broadcast(
+            VirtualHand, ActorThumbTouching, ActorIndexTouching, ActorMiddleTouching,
+            ActorRingTouching, ActorPinkyTouching);
    }
 }

@@ -36,6 +36,7 @@
 #pragma once

 #include "GameFramework/Pawn.h"
+#include "SenseGlove/Components/SGVirtualHandComponent.h"
 #include "Templates/UniquePtr.h"

 #include "SGPawn.generated.h"
@@ -51,6 +52,30 @@ class SENSEGLOVE_API ASGPawn : public APawn
 {
    GENERATED_UCLASS_BODY()

+public:
+    DECLARE_EVENT_FourParams(
+        ASGPawn, FGrabStateUpdatedEvent, const USGVirtualHandComponent*,
+        const AActor* ActorThumbCanGrab, const AActor* ActorIndexCanGrab, const AActor* ActorMiddleCanGrab);
+
+    FGrabStateUpdatedEvent& OnGrabStateUpdated()
+    {
+        return GrabStateUpdatedEvent;
+    };
+
+    DECLARE_EVENT_SixParams(
+        ASGPawn, FTouchStateUpdatedEvent, const USGVirtualHandComponent*,
+        const AActor* ActorThumbTouching, const AActor* ActorIndexTouching, const AActor* ActorMiddleTouching,
+        const AActor* ActorRingTouching, const AActor* ActorPinkyTouching);
+
+    FTouchStateUpdatedEvent& OnTouchStateUpdated()
+    {
+        return TouchStateUpdatedEvent;
+    };
+
+private:
+    FGrabStateUpdatedEvent GrabStateUpdatedEvent;
+    FTouchStateUpdatedEvent TouchStateUpdatedEvent;
+
 private:
    struct FImpl;

@@ -57,6 +57,30 @@ class SENSEGLOVE_API ASGVirtualHandActor : public AActor
 {
    GENERATED_UCLASS_BODY()

+public:
+    DECLARE_EVENT_FourParams(
+        ASGVirtualHandActor, FGrabStateUpdatedEvent, const USGVirtualHandComponent*,
+        const AActor* ActorThumbCanGrab, const AActor* ActorIndexCanGrab, const AActor* ActorMiddleCanGrab);
+
+    FGrabStateUpdatedEvent& OnGrabStateUpdated()
+    {
+        return GrabStateUpdatedEvent;
+    };
+
+    DECLARE_EVENT_SixParams(
+        ASGVirtualHandActor, FTouchStateUpdatedEvent, const USGVirtualHandComponent*,
+        const AActor* ActorThumbTouching, const AActor* ActorIndexTouching, const AActor* ActorMiddleTouching,
+        const AActor* ActorRingTouching, const AActor* ActorPinkyTouching);
+
+    FTouchStateUpdatedEvent& OnTouchStateUpdated()
+    {
+        return TouchStateUpdatedEvent;
+    };
+
+private:
+    FGrabStateUpdatedEvent GrabStateUpdatedEvent;
+    FTouchStateUpdatedEvent TouchStateUpdatedEvent;
+
 private:
    struct FImpl;