add as*glove/device casting methods that resolves the sgpawn vibrotactile issues

Source/SenseGloveCore/Private/SGCore/SGDevice.cpp

@@ -347,36 +347,56 @@ bool USGDevice::IsASenseGlove() const
 
 USGBetaDevice* USGDevice::AsBetaDevice(UObject* Outer) const
 {
+    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
+    FSGIC_TSharedPtr_FSGBetaDeviceImpl OutSharedPtr;
+    SGCoreImpl_FSGDeviceImpl_AsBetaDevice(&InstanceContainer, &OutSharedPtr);
+
     USGBetaDevice* BetaDevice = NewObject<USGBetaDevice>(Outer);
-    BetaDevice->SetSGDeviceImpl(FSGDeviceImplCast::ToBetaDeviceImpl(ToSGDeviceImpl()));
+    BetaDevice->SetSGDeviceImpl(OutSharedPtr.Ptr.ToSharedRef());
     return BetaDevice;
 }
 
 USGHapticGlove* USGDevice::AsHapticGlove(UObject* Outer) const
 {
+    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
+    FSGIC_TSharedPtr_FSGHapticGloveImpl OutSharedPtr;
+    SGCoreImpl_FSGDeviceImpl_AsHapticGlove(&InstanceContainer, &OutSharedPtr);
+
     USGHapticGlove* HapticGlove = NewObject<USGHapticGlove>(Outer);
-    HapticGlove->SetSGDeviceImpl(FSGDeviceImplCast::ToHapticGloveImpl(ToSGDeviceImpl()));
+    HapticGlove->SetSGDeviceImpl(OutSharedPtr.Ptr.ToSharedRef());
     return HapticGlove;
 }
 
 USGNova2Glove* USGDevice::AsNova2Glove(UObject* Outer) const
 {
+    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
+    FSGIC_TSharedPtr_FSGNova2GloveImpl OutSharedPtr;
+    SGCoreImpl_FSGDeviceImpl_AsNova2Glove(&InstanceContainer, &OutSharedPtr);
+
     USGNova2Glove* Nova2Glove = NewObject<USGNova2Glove>(Outer);
-    Nova2Glove->SetSGDeviceImpl(FSGDeviceImplCast::ToNova2GloveImpl(ToSGDeviceImpl()));
+    Nova2Glove->SetSGDeviceImpl(OutSharedPtr.Ptr.ToSharedRef());
     return Nova2Glove;
 }
 
 USGNovaGlove* USGDevice::AsNovaGlove(UObject* Outer) const
 {
+    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
+    FSGIC_TSharedPtr_FSGNovaGloveImpl OutSharedPtr;
+    SGCoreImpl_FSGDeviceImpl_AsNovaGlove(&InstanceContainer, &OutSharedPtr);
+
     USGNovaGlove* NovaGlove = NewObject<USGNovaGlove>(Outer);
-    NovaGlove->SetSGDeviceImpl(FSGDeviceImplCast::ToNovaGloveImpl(ToSGDeviceImpl()));
+    NovaGlove->SetSGDeviceImpl(OutSharedPtr.Ptr.ToSharedRef());
     return NovaGlove;
 }
 
 USGSenseGlove* USGDevice::AsSenseGlove(UObject* Outer) const
 {
+    FSGIC_TSharedPtr_FSGDeviceImpl InstanceContainer{ToSGDeviceImpl()};
+    FSGIC_TSharedPtr_FSGSenseGloveImpl OutSharedPtr;
+    SGCoreImpl_FSGDeviceImpl_AsSenseGlove(&InstanceContainer, &OutSharedPtr);
+
     USGSenseGlove* SenseGlove = NewObject<USGSenseGlove>(Outer);
-    SenseGlove->SetSGDeviceImpl(FSGDeviceImplCast::ToSenseGloveImpl(ToSGDeviceImpl()));
+    SenseGlove->SetSGDeviceImpl(OutSharedPtr.Ptr.ToSharedRef());
     return SenseGlove;
 }
 

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGDeviceImpl.cpp

@@ -224,6 +224,51 @@ bool FSGDeviceImpl::IsASenseGlove() const
     return SenseGlove != nullptr;
 }
 
+TSharedPtr<FSGBetaDeviceImpl> FSGDeviceImpl::AsBetaDevice() const
+{
+    const FSGBetaDeviceImpl::FBetaDevicePtrType BetaDevice{
+        std::dynamic_pointer_cast<FSGBetaDeviceImpl::FBetaDeviceType>(ToSGDevicePtr())
+    };
+    ensureAlwaysMsgf(BetaDevice, TEXT("Invalid BetaDevice!"));
+    return MakeShared<FSGBetaDeviceImpl>(BetaDevice);
+}
+
+TSharedPtr<FSGHapticGloveImpl> FSGDeviceImpl::AsHapticGlove() const
+{
+    const FSGHapticGloveImpl::FHapticGlovePtrType HapticGlove{
+        std::dynamic_pointer_cast<FSGHapticGloveImpl::FHapticGloveType>(ToSGDevicePtr())
+    };
+    ensureAlwaysMsgf(HapticGlove, TEXT("Invalid HapticGlove!"));
+    return MakeShared<FSGHapticGloveImpl>(HapticGlove);
+}
+
+TSharedPtr<FSGNova2GloveImpl> FSGDeviceImpl::AsNova2Glove() const
+{
+    const FSGNova2GloveImpl::FNova2GlovePtrType Nova2Glove{
+        std::dynamic_pointer_cast<FSGNova2GloveImpl::FNova2GloveType>(ToSGDevicePtr())
+    };
+    ensureAlwaysMsgf(Nova2Glove, TEXT("Invalid Nova2Glove!"));
+    return MakeShared<FSGNova2GloveImpl>(Nova2Glove);
+}
+
+TSharedPtr<FSGNovaGloveImpl> FSGDeviceImpl::AsNovaGlove() const
+{
+    const FSGNovaGloveImpl::FNovaGlovePtrType NovaGlove{
+        std::dynamic_pointer_cast<FSGNovaGloveImpl::FNovaGloveType>(ToSGDevicePtr())
+    };
+    ensureAlwaysMsgf(NovaGlove, TEXT("Invalid NovaGlove!"));
+    return MakeShared<FSGNovaGloveImpl>(NovaGlove);
+}
+
+TSharedPtr<FSGSenseGloveImpl> FSGDeviceImpl::AsSenseGlove() const
+{
+    const FSGSenseGloveImpl::FSenseGlovePtrType SenseGlove{
+        std::dynamic_pointer_cast<FSGSenseGloveImpl::FSenseGloveType>(ToSGDevicePtr())
+    };
+    ensureAlwaysMsgf(SenseGlove, TEXT("Invalid SenseGlove!"));
+    return MakeShared<FSGSenseGloveImpl>(SenseGlove);
+}
+
 ESGDeviceType FSGDeviceImpl::GetDeviceType() const
 {
     return FSGCoreEnumCast::ToESGDeviceType(ToSGDevicePtrChecked()->GetDeviceType());

Source/SenseGloveCoreImpl/Private/SGCoreImpl/SGExportedFunctions.cpp

@@ -1102,6 +1102,46 @@ bool SGCoreImpl_FSGDeviceImpl_IsASenseGlove(
     return StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->IsASenseGlove();
 }
 
+void SGCoreImpl_FSGDeviceImpl_AsBetaDevice(
+    void* Instance,
+    void* OutSharedPtr)
+{
+    StaticCast<FSGIC_TSharedPtr_FSGBetaDeviceImpl*>(OutSharedPtr)->Ptr =
+        StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->AsBetaDevice();
+}
+
+void SGCoreImpl_FSGDeviceImpl_AsHapticGlove(
+    void* Instance,
+    void* OutSharedPtr)
+{
+    StaticCast<FSGIC_TSharedPtr_FSGHapticGloveImpl*>(OutSharedPtr)->Ptr =
+        StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->AsHapticGlove();
+}
+
+void SGCoreImpl_FSGDeviceImpl_AsNova2Glove(
+    void* Instance,
+    void* OutSharedPtr)
+{
+    StaticCast<FSGIC_TSharedPtr_FSGNova2GloveImpl*>(OutSharedPtr)->Ptr =
+        StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->AsNova2Glove();
+}
+
+void SGCoreImpl_FSGDeviceImpl_AsNovaGlove(
+    void* Instance,
+    void* OutSharedPtr)
+{
+    StaticCast<FSGIC_TSharedPtr_FSGNovaGloveImpl*>(OutSharedPtr)->Ptr =
+        StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->AsNovaGlove();
+}
+
+void SGCoreImpl_FSGDeviceImpl_AsSenseGlove(
+    void* Instance,
+    void* OutSharedPtr)
+{
+    StaticCast<FSGIC_TSharedPtr_FSGSenseGloveImpl*>(OutSharedPtr)->Ptr =
+        StaticCast<FSGIC_TSharedPtr_FSGDeviceImpl*>(Instance)->Ptr->AsSenseGlove();
+}
+
 void SGCoreImpl_FSGDeviceImpl_GetDeviceType(
     void* Instance,
     void* OutType)

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGDeviceImpl.h

@@ -173,6 +173,13 @@ public:
     bool IsANovaGlove() const;
     bool IsASenseGlove() const;
 
+public:
+    TSharedPtr<FSGBetaDeviceImpl> AsBetaDevice() const;
+    TSharedPtr<FSGHapticGloveImpl> AsHapticGlove() const;
+    TSharedPtr<FSGNova2GloveImpl> AsNova2Glove() const;
+    TSharedPtr<FSGNovaGloveImpl> AsNovaGlove() const;
+    TSharedPtr<FSGSenseGloveImpl> AsSenseGlove() const;
+
 public:
     virtual ESGDeviceType GetDeviceType() const;
 

Source/SenseGloveCoreImpl/Public/SGCoreImpl/SGExportedFunctions.h

@@ -568,6 +568,26 @@ SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGDeviceImpl_IsANovaGlove(
 SENSEGLOVECOREIMPL_PUBLIC_API bool SGCoreImpl_FSGDeviceImpl_IsASenseGlove(
     void* Instance);
 
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceImpl_AsBetaDevice(
+    void* Instance,
+    void* OutSharedPtr);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceImpl_AsHapticGlove(
+    void* Instance,
+    void* OutSharedPtr);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceImpl_AsNova2Glove(
+    void* Instance,
+    void* OutSharedPtr);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceImpl_AsNovaGlove(
+    void* Instance,
+    void* OutSharedPtr);
+
+SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceImpl_AsSenseGlove(
+    void* Instance,
+    void* OutSharedPtr);
+
 SENSEGLOVECOREIMPL_PUBLIC_API void SGCoreImpl_FSGDeviceImpl_GetDeviceType(
     void* Instance,
     void* OutType);