diff --git a/.idea/.idea.Faye.dir/.idea/vcs.xml b/.idea/.idea.Faye.dir/.idea/vcs.xml
new file mode 100644
index 0000000..35eb1dd
--- /dev/null
+++ b/.idea/.idea.Faye.dir/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Automation_Faye.slnx b/Automation_Faye.slnx
new file mode 100644
index 0000000..48249a1
--- /dev/null
+++ b/Automation_Faye.slnx
@@ -0,0 +1,65 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Config/DefaultEngine.ini b/Config/DefaultEngine.ini
index bc677d9..c44732a 100644
--- a/Config/DefaultEngine.ini
+++ b/Config/DefaultEngine.ini
@@ -13,7 +13,6 @@ r.Mobile.SupportGPUScene=True
r.Mobile.AntiAliasing=1
r.Mobile.FloatPrecisionMode=0
r.Mobile.AllowDitheredLODTransition=False
-r.Mobile.VirtualTextures=False
r.DiscardUnusedQuality=False
r.AllowOcclusionQueries=True
r.MinScreenRadiusForLights=0.030000
diff --git a/Faye.slnx b/Faye.slnx
new file mode 100644
index 0000000..dc99064
--- /dev/null
+++ b/Faye.slnx
@@ -0,0 +1,228 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Faye.uproject b/Faye.uproject
index db736f3..4716dbb 100644
--- a/Faye.uproject
+++ b/Faye.uproject
@@ -1,6 +1,6 @@
{
"FileVersion": 3,
- "EngineAssociation": "5.7",
+ "EngineAssociation": "5.8",
"Category": "",
"Description": "",
"Modules": [
@@ -106,27 +106,9 @@
"Name": "CameraShakePreviewer",
"Enabled": false
},
- {
- "Name": "GameplayCameras",
- "Enabled": false
- },
{
"Name": "StructUtils",
"Enabled": true
- },
- {
- "Name": "Rive",
- "Enabled": true
- },
- {
- "Name": "Diversion",
- "Enabled": true,
- "MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/7c8abd783acd4d66a5290a12a5d67523"
- },
- {
- "Name": "LTween",
- "Enabled": true,
- "MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/efa1b6e762974e48847e029c8ac6c602"
}
]
}
\ No newline at end of file
diff --git a/Plugins/ArrayHelper/ArrayHelper.uplugin b/Plugins/ArrayHelper/ArrayHelper.uplugin
index c2c9543..ad25c9c 100644
--- a/Plugins/ArrayHelper/ArrayHelper.uplugin
+++ b/Plugins/ArrayHelper/ArrayHelper.uplugin
@@ -10,7 +10,7 @@
"DocsURL": "https://github.com/RLoris/ArrayHelperDoc/blob/master/README.md",
"MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/813e339b92ad4cf587a4cef56bec7020",
"SupportURL": "https://forms.gle/CpekZfTewGZrUVen7",
- "EngineVersion": "5.7.0",
+ "EngineVersion": "5.8.0",
"CanContainContent": true,
"Installed": true,
"Modules": [
diff --git a/Plugins/LTween/LTween.uplugin b/Plugins/LTween/LTween.uplugin
new file mode 100644
index 0000000..629d8e8
--- /dev/null
+++ b/Plugins/LTween/LTween.uplugin
@@ -0,0 +1,30 @@
+{
+ "FileVersion": 3,
+ "Version": 1,
+ "VersionName": "1.3",
+ "FriendlyName": "LTween",
+ "Description": "LTween (Lex-Tween) is a tween animation library",
+ "Category": "LexPlugin",
+ "CreatedBy": "LexLiu",
+ "CreatedByURL": "",
+ "DocsURL": "https://liufei2008.github.io/LTweenDoc/GetStarted/",
+ "MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/efa1b6e762974e48847e029c8ac6c602",
+ "SupportURL": "707908214@qq.com",
+ "EngineVersion": "5.8.0",
+ "CanContainContent": true,
+ "Installed": true,
+ "Modules": [
+ {
+ "Name": "LTween",
+ "Type": "Runtime",
+ "LoadingPhase": "Default",
+ "PlatformAllowList": [
+ "Win64",
+ "Mac",
+ "Linux",
+ "IOS",
+ "Android"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Plugins/LTween/Resources/Icon128.png b/Plugins/LTween/Resources/Icon128.png
new file mode 100644
index 0000000..af52f27
--- /dev/null
+++ b/Plugins/LTween/Resources/Icon128.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f5035e24bdc95f840ce60708608c0eb7e2f3249cd8b72916df3acabb10d14ee
+size 5204
diff --git a/Plugins/LTween/Source/LTween/LTween.Build.cs b/Plugins/LTween/Source/LTween/LTween.Build.cs
new file mode 100644
index 0000000..de3c7d3
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/LTween.Build.cs
@@ -0,0 +1,40 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class LTween : ModuleRules
+{
+ public LTween(ReadOnlyTargetRules Target) : base(Target)
+ {
+ PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+ PublicDependencyModuleNames.AddRange(
+ new string[]
+ {
+ "Core",
+ "Engine",
+
+ // ... add other public dependencies that you statically link with here ...
+ }
+ );
+
+
+ PrivateDependencyModuleNames.AddRange(
+ new string[]
+ {
+ "CoreUObject",
+ "UMG",
+ "SlateCore",
+ // ... add private dependencies that you statically link with here ...
+ }
+ );
+
+
+ DynamicallyLoadedModuleNames.AddRange(
+ new string[]
+ {
+ // ... add any modules that your module loads dynamically here ...
+ }
+ );
+
+ }
+}
diff --git a/Plugins/LTween/Source/LTween/Private/LTween.cpp b/Plugins/LTween/Source/LTween/Private/LTween.cpp
new file mode 100644
index 0000000..12278a0
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/LTween.cpp
@@ -0,0 +1,21 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#include "LTween.h"
+#include "Modules/ModuleManager.h"
+
+DEFINE_LOG_CATEGORY(LTween);
+
+void FLTweenModule::StartupModule()
+{
+ // This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+
+}
+
+void FLTweenModule::ShutdownModule()
+{
+ // This function may be called during shutdown to clean up your module. For modules that support dynamic reloading,
+ // we call this function before unloading the module.
+
+}
+
+IMPLEMENT_MODULE(FLTweenModule, LTween)//if second param is wrong, an error like "EmptyLinkFunctionForStaticInitialization(XXX)" will occor when package project
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/LTweenBPLibrary.cpp b/Plugins/LTween/Source/LTween/Private/LTweenBPLibrary.cpp
new file mode 100644
index 0000000..ef1f6b9
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/LTweenBPLibrary.cpp
@@ -0,0 +1,1222 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#include "LTweenBPLibrary.h"
+#include "LTween.h"
+#include "Components/SceneComponent.h"
+#include "Materials/MaterialInstanceDynamic.h"
+#include "Components/MeshComponent.h"
+
+
+ULTweener* ULTweenBPLibrary::FloatTo(UObject* WorldContextObject, const FLTweenFloatSetterDynamic& setter, float startValue, float endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenFloatGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenFloatSetterFunction::CreateLambda([setter](float value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::DoubleTo(UObject* WorldContextObject, const FLTweenDoubleSetterDynamic& setter, double startValue, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenDoubleGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenDoubleSetterFunction::CreateLambda([setter](auto value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::IntTo(UObject* WorldContextObject, const FLTweenIntSetterDynamic& setter, int startValue, int endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenIntGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenIntSetterFunction::CreateLambda([setter](int value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::Vector2To(UObject* WorldContextObject, const FLTweenVector2SetterDynamic& setter, FVector2D startValue, FVector2D endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector2DGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenVector2DSetterFunction::CreateLambda([setter](const FVector2D& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::Vector3To(UObject* WorldContextObject, const FLTweenVector3SetterDynamic& setter, FVector startValue, FVector endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVectorGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenVectorSetterFunction::CreateLambda([setter](const FVector& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::Vector4To(UObject* WorldContextObject, const FLTweenVector4SetterDynamic& setter, FVector4 startValue, FVector4 endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector4GetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenVector4SetterFunction::CreateLambda([setter](const FVector4& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::ColorTo(UObject* WorldContextObject, const FLTweenColorSetterDynamic& setter, FColor startValue, FColor endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenColorGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenColorSetterFunction::CreateLambda([setter](const FColor& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LinearColorTo(UObject* WorldContextObject, const FLTweenLinearColorSetterDynamic& setter, FLinearColor startValue, FLinearColor endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenLinearColorGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenLinearColorSetterFunction::CreateLambda([setter](const FLinearColor& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::QuaternionTo(UObject* WorldContextObject, const FLTweenQuaternionSetterDynamic& setter, FQuat startValue, FQuat endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenQuaternionGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenQuaternionSetterFunction::CreateLambda([setter](const FQuat& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::RotatorTo(UObject* WorldContextObject, const FLTweenRotatorSetterDynamic& setter, FRotator startValue, FRotator endValue, float duration, float delay, ELTweenEase ease)
+{
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenRotatorGetterFunction::CreateLambda([startValue]
+ {
+ return startValue;
+ }), FLTweenRotatorSetterFunction::CreateLambda([setter](const FRotator& value)
+ {
+ if (setter.IsBound())
+ setter.Execute(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+
+#pragma region PositionXYZ
+ULTweener* ULTweenBPLibrary::LocalPositionXTo(USceneComponent* target, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionXTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeLocation().X;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target](auto value) {
+ auto location = target->GetRelativeLocation();
+ location.X = value;
+ target->SetRelativeLocation(location);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalPositionYTo(USceneComponent* target, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionYTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeLocation().Y;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target](auto value) {
+ auto location = target->GetRelativeLocation();
+ location.Y = value;
+ target->SetRelativeLocation(location);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalPositionZTo(USceneComponent* target, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionZTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeLocation().Z;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [=](auto value) {
+ auto location = target->GetRelativeLocation();
+ location.Z = value;
+ target->SetRelativeLocation(location);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalPositionXTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionXTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeLocation().X;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](auto value) {
+ auto location = target->GetRelativeLocation();
+ location.X = value;
+ target->SetRelativeLocation(location, teleport, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalPositionYTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionYTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeLocation().Y;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](auto value) {
+ auto location = target->GetRelativeLocation();
+ location.Y = value;
+ target->SetRelativeLocation(location, teleport, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalPositionZTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionZTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeLocation().Z;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](auto value) {
+ auto location = target->GetRelativeLocation();
+ location.Z = value;
+ target->SetRelativeLocation(location, teleport, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+
+
+
+ULTweener* ULTweenBPLibrary::WorldPositionXTo(USceneComponent* target, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionXTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentLocation().X;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target](auto value) {
+ auto location = target->GetComponentLocation();
+ location.X = value;
+ target->SetWorldLocation(location);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionYTo(USceneComponent* target, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionYTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentLocation().Y;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target](auto value) {
+ auto location = target->GetComponentLocation();
+ location.Y = value;
+ target->SetWorldLocation(location);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionZTo(USceneComponent* target, double endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionZTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentLocation().Z;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target](auto value) {
+ auto location = target->GetComponentLocation();
+ location.Z = value;
+ target->SetWorldLocation(location);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionXTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionXTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentLocation().X;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](auto value) {
+ auto location = target->GetComponentLocation();
+ location.X = value;
+ target->SetWorldLocation(location, teleport, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionYTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionYTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentLocation().Y;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](auto value) {
+ auto location = target->GetComponentLocation();
+ location.Y = value;
+ target->SetWorldLocation(location, teleport, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionZTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionZTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenDoubleGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentLocation().Z;
+ }), FLTweenDoubleSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](auto value) {
+ auto location = target->GetComponentLocation();
+ location.Z = value;
+ target->SetWorldLocation(location, teleport, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+#pragma endregion PositionXYZ
+
+
+
+
+#pragma region Position
+ULTweener* ULTweenBPLibrary::LocalPositionTo(USceneComponent* target, FVector endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenPositionGetterFunction::CreateUObject(target, &USceneComponent::GetRelativeLocation)
+ , FLTweenPositionSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeLocation)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionTo(USceneComponent* target, FVector endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenPositionGetterFunction::CreateUObject(target, &USceneComponent::GetComponentLocation)
+ , FLTweenPositionSetterFunction::CreateUObject(target, &USceneComponent::SetWorldLocation)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalPositionTo_Sweep(USceneComponent* target, FVector endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalPositionTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenVectorGetterFunction::CreateUObject(target, &USceneComponent::GetRelativeLocation)
+ , FLTweenPositionSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeLocation)
+ , endValue, duration, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldPositionTo_Sweep(USceneComponent* target, FVector endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldPositionTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenPositionGetterFunction::CreateUObject(target, &USceneComponent::GetComponentLocation)
+ , FLTweenPositionSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeLocation)
+ , endValue, duration, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+#pragma endregion Position
+
+
+
+ULTweener* ULTweenBPLibrary::LocalScaleTo(USceneComponent* target, FVector endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalScaleTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenVectorGetterFunction::CreateUObject(target, &USceneComponent::GetRelativeScale3D)
+ , FLTweenVectorSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeScale3D)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+
+
+#pragma region Rotation
+ULTweener* ULTweenBPLibrary::LocalRotateEulerAngleTo(USceneComponent* target, FVector eulerAngle, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalRotateEulerAngleTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeRotationCache().GetCachedQuat();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeRotation)
+ , eulerAngle, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalRotationQuaternionTo(USceneComponent* target, const FQuat& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalRotationTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeRotationCache().GetCachedQuat();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeRotation)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalRotateEulerAngleTo_Sweep(USceneComponent* target, FVector eulerAngle, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalRotateEulerAngleTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeRotationCache().GetCachedQuat();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeRotation)
+ , eulerAngle, duration, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalRotationQuaternionTo_Sweep(USceneComponent* target, const FQuat& endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalRotationTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetRelativeRotationCache().GetCachedQuat();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetRelativeRotation)
+ , endValue, duration, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::LocalRotatorTo(USceneComponent* target, FRotator endValue, bool shortestPath, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalRotatorTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ if (shortestPath)
+ {
+ return LocalRotationQuaternionTo(target, endValue.Quaternion(), duration, delay, ease);
+ }
+ else
+ {
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenRotatorGetterFunction::CreateUObject(target, &USceneComponent::GetRelativeRotation)
+ , FLTweenRotatorSetterFunction::CreateWeakLambda(target, [target] (FRotator value)
+ {
+ target->SetRelativeRotation(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+ }
+}
+ULTweener* ULTweenBPLibrary::LocalRotatorTo_Sweep(USceneComponent* target, FRotator endValue, bool shortestPath, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::LocalRotatorTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ if (shortestPath)
+ {
+ return LocalRotationQuaternionTo_Sweep(target, endValue.Quaternion(), sweepHitResult, sweep, teleport, duration, delay, ease);
+ }
+ else
+ {
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenRotatorGetterFunction::CreateUObject(target, &USceneComponent::GetRelativeRotation)
+ , FLTweenRotatorSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](FRotator value)
+ {
+ target->SetRelativeRotation(value, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+ }
+}
+
+
+
+ULTweener* ULTweenBPLibrary::WorldRotateEulerAngleTo(USceneComponent* target, FVector eulerAngle, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldRotateEulerAngleTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentRotation().Quaternion();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetWorldRotation)
+ , eulerAngle, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldRotationQuaternionTo(USceneComponent* target, const FQuat& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldRotationTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentRotation().Quaternion();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetWorldRotation)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldRotateEulerAngleTo_Sweep(USceneComponent* target, FVector eulerAngle, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldRotateEulerAngleTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentRotation().Quaternion();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetWorldRotation)
+ , eulerAngle, duration, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldRotationQuaternionTo_Sweep(USceneComponent* target, const FQuat& endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldRotationTo_Sweep] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(target, FLTweenRotationQuatGetterFunction::CreateWeakLambda(target, [target]
+ {
+ return target->GetComponentRotation().Quaternion();
+ }), FLTweenRotationQuatSetterFunction::CreateUObject(target, &USceneComponent::SetWorldRotation)
+ , endValue, duration, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::WorldRotatorTo(USceneComponent* target, FRotator endValue, bool shortestPath, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldRotatorTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ if (shortestPath)
+ {
+ return WorldRotationQuaternionTo(target, endValue.Quaternion(), duration, delay, ease);
+ }
+ else
+ {
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenRotatorGetterFunction::CreateUObject(target, &USceneComponent::GetComponentRotation)
+ , FLTweenRotatorSetterFunction::CreateWeakLambda(target, [target](FRotator value)
+ {
+ target->SetWorldRotation(value);
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+ }
+}
+ULTweener* ULTweenBPLibrary::WorldRotatorTo_Sweep(USceneComponent* target, FRotator endValue, bool shortestPath, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::WorldRotatorTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ if (shortestPath)
+ {
+ return WorldRotationQuaternionTo_Sweep(target, endValue.Quaternion(), sweepHitResult, sweep, teleport, duration, delay, ease);
+ }
+ else
+ {
+ auto Tweener = ULTweenManager::To(target
+ , FLTweenRotatorGetterFunction::CreateUObject(target, &USceneComponent::GetComponentRotation)
+ , FLTweenRotatorSetterFunction::CreateWeakLambda(target, [target, &sweepHitResult, sweep, teleport](FRotator value)
+ {
+ target->SetWorldRotation(value, sweep, sweep ? &sweepHitResult : nullptr, TeleportFlagToEnum(teleport));
+ }), endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+ }
+}
+#pragma endregion Rotation
+
+
+#pragma region Material
+ULTweener* ULTweenBPLibrary::MaterialScalarParameterTo(UObject* WorldContextObject, UMaterialInstanceDynamic* target, FName parameterName, float endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(WorldContextObject))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::MaterialScalarParameterTo] WorldContextObject is not valid!"));
+ return nullptr;
+ }
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::MaterialScalarParameterTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ float startValue = 0;
+ int32 parameterIndex = 0;
+ if (target->GetScalarParameterValue(parameterName, startValue))
+ {
+ target->InitializeScalarParameterAndGetIndex(parameterName, startValue, parameterIndex);
+ }
+ else
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweenBPLibrary::MaterialScalarParameterTo]GetScalarParameterValue:%s error!"), *(parameterName.ToString()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenMaterialScalarGetterFunction::CreateWeakLambda(target, [target, parameterName](float& result)
+ {
+ return target->GetScalarParameterValue(parameterName, result);
+ }), FLTweenMaterialScalarSetterFunction::CreateUObject(target, &UMaterialInstanceDynamic::SetScalarParameterByIndex)
+ , endValue, duration, parameterIndex);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::MaterialVectorParameterTo(UObject* WorldContextObject, UMaterialInstanceDynamic* target, FName parameterName, FLinearColor endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(WorldContextObject))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::MaterialVectorParameterTo] WorldContextObject is not valid!"));
+ return nullptr;
+ }
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::MaterialVectorParameterTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ FLinearColor startValue = FLinearColor();
+ int32 parameterIndex = 0;
+ if (target->GetVectorParameterValue(parameterName, startValue))
+ {
+ target->InitializeVectorParameterAndGetIndex(parameterName, startValue, parameterIndex);
+ }
+ else
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweenBPLibrary::MaterialVectorParameterTo]GetVectorParameterValue:%s error!"), *(parameterName.ToString()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenMaterialVectorGetterFunction::CreateWeakLambda(target, [target, parameterName](FLinearColor& result)
+ {
+ return target->GetVectorParameterValue(parameterName, result);
+ }), FLTweenMaterialVectorSetterFunction::CreateUObject(target, &UMaterialInstanceDynamic::SetVectorParameterByIndex)
+ , endValue, duration, parameterIndex);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+
+ULTweener* ULTweenBPLibrary::MeshMaterialScalarParameterTo(UPrimitiveComponent* target, int materialIndex, FName parameterName, float endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::MeshMaterialScalarParameterTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ float startValue = 0;
+ int32 parameterIndex = 0;
+ auto material = target->CreateAndSetMaterialInstanceDynamic(parameterIndex);
+ if (material->GetScalarParameterValue(parameterName, startValue))
+ {
+ material->InitializeScalarParameterAndGetIndex(parameterName, startValue, parameterIndex);
+ }
+ else
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweenBPLibrary::MaterialScalarParameterTo]GetScalarParameterValue:%s error!"), *(parameterName.ToString()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(material, FLTweenMaterialScalarGetterFunction::CreateWeakLambda(material, [material, parameterName](float& result)
+ {
+ return material->GetScalarParameterValue(parameterName, result);
+ }), FLTweenMaterialScalarSetterFunction::CreateUObject(material, &UMaterialInstanceDynamic::SetScalarParameterByIndex)
+ , endValue, duration, parameterIndex);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::MeshMaterialVectorParameterTo(UPrimitiveComponent* target, int materialIndex, FName parameterName, FLinearColor endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenBPLibrary::MeshMaterialVectorParameterTo] target is not valid:%s"), *(target->GetPathName()));
+ return nullptr;
+ }
+ FLinearColor startValue = FLinearColor();
+ int32 parameterIndex = 0;
+ auto material = target->CreateAndSetMaterialInstanceDynamic(parameterIndex);
+ if (material->GetVectorParameterValue(parameterName, startValue))
+ {
+ material->InitializeVectorParameterAndGetIndex(parameterName, startValue, parameterIndex);
+ }
+ else
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweenBPLibrary::MaterialVectorParameterTo]GetVectorParameterValue:%s error!"), *(parameterName.ToString()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(material, FLTweenMaterialVectorGetterFunction::CreateWeakLambda(material, [material, parameterName](FLinearColor& result)
+ {
+ return material->GetVectorParameterValue(parameterName, result);
+ }), FLTweenMaterialVectorSetterFunction::CreateUObject(material, &UMaterialInstanceDynamic::SetVectorParameterByIndex)
+ , endValue, duration, parameterIndex);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease);
+ }
+ return Tweener;
+}
+#pragma endregion
+
+#pragma region UMG
+#include "Components/CanvasPanelSlot.h"
+ULTweener* ULTweenBPLibrary::UMG_CanvasPanelSlot_PositionTo(UObject* WorldContextObject, UCanvasPanelSlot* target, const FVector2D& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject
+ , FLTweenVector2DGetterFunction::CreateUObject(target, &UCanvasPanelSlot::GetPosition)
+ , FLTweenVector2DSetterFunction::CreateUObject(target, &UCanvasPanelSlot::SetPosition)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::UMG_CanvasPanelSlot_SizeTo(UObject* WorldContextObject, class UCanvasPanelSlot* target, const FVector2D& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject
+ , FLTweenVector2DGetterFunction::CreateUObject(target, &UCanvasPanelSlot::GetSize)
+ , FLTweenVector2DSetterFunction::CreateUObject(target, &UCanvasPanelSlot::SetSize)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/HorizontalBoxSlot.h"
+ULTweener* ULTweenBPLibrary::UMG_HorizontalBoxSlot_PaddingTo(UObject* WorldContextObject, UHorizontalBoxSlot* target, const FMargin& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto endValueVector4 = FVector4(endValue.Left, endValue.Top, endValue.Right, endValue.Bottom);
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector4GetterFunction::CreateWeakLambda(target, [=]
+ {
+ auto padding = target->GetPadding();
+ return FVector4(padding.Left, padding.Top, padding.Right, padding.Bottom);
+ }), FLTweenVector4SetterFunction::CreateWeakLambda(target, [=](const FVector4& value) {
+ target->SetPadding(FMargin(value.X, value.Y, value.Z, value.W));
+ }), endValueVector4, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/VerticalBoxSlot.h"
+ULTweener* ULTweenBPLibrary::UMG_VerticalBoxSlot_PaddingTo(UObject* WorldContextObject, UVerticalBoxSlot* target, const FMargin& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto endValueVector4 = FVector4(endValue.Left, endValue.Top, endValue.Right, endValue.Bottom);
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector4GetterFunction::CreateWeakLambda(target, [=]
+ {
+ auto padding = target->GetPadding();
+ return FVector4(padding.Left, padding.Top, padding.Right, padding.Bottom);
+ }), FLTweenVector4SetterFunction::CreateWeakLambda(target, [=](const FVector4& value) {
+ target->SetPadding(FMargin(value.X, value.Y, value.Z, value.W));
+ }), endValueVector4, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/OverlaySlot.h"
+ULTweener* ULTweenBPLibrary::UMG_OverlaySlot_PaddingTo(UObject* WorldContextObject, UOverlaySlot* target, const FMargin& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto endValueVector4 = FVector4(endValue.Left, endValue.Top, endValue.Right, endValue.Bottom);
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector4GetterFunction::CreateWeakLambda(target, [=]
+ {
+ auto padding = target->GetPadding();
+ return FVector4(padding.Left, padding.Top, padding.Right, padding.Bottom);
+ }), FLTweenVector4SetterFunction::CreateWeakLambda(target, [=](const FVector4& value) {
+ target->SetPadding(FMargin(value.X, value.Y, value.Z, value.W));
+ }), endValueVector4, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/ButtonSlot.h"
+ULTweener* ULTweenBPLibrary::UMG_ButtonSlot_PaddingTo(UObject* WorldContextObject, UButtonSlot* target, const FMargin& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto endValueVector4 = FVector4(endValue.Left, endValue.Top, endValue.Right, endValue.Bottom);
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector4GetterFunction::CreateWeakLambda(target, [=]
+ {
+ auto padding = target->GetPadding();
+ return FVector4(padding.Left, padding.Top, padding.Right, padding.Bottom);
+ }), FLTweenVector4SetterFunction::CreateWeakLambda(target, [=](const FVector4& value) {
+ target->SetPadding(FMargin(value.X, value.Y, value.Z, value.W));
+ }), endValueVector4, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/BorderSlot.h"
+ULTweener* ULTweenBPLibrary::UMG_BorderSlot_PaddingTo(UObject* WorldContextObject, UBorderSlot* target, const FMargin& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto endValueVector4 = FVector4(endValue.Left, endValue.Top, endValue.Right, endValue.Bottom);
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector4GetterFunction::CreateWeakLambda(target, [=]
+ {
+ auto padding = target->GetPadding();
+ return FVector4(padding.Left, padding.Top, padding.Right, padding.Bottom);
+ }), FLTweenVector4SetterFunction::CreateWeakLambda(target, [=](const FVector4& value) {
+ target->SetPadding(FMargin(value.X, value.Y, value.Z, value.W));
+ }), endValueVector4, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+
+#include "Components/Widget.h"
+ULTweener* ULTweenBPLibrary::UMG_RenderTransform_TranslationTo(UObject* WorldContextObject, class UWidget* target, const FVector2D& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector2DGetterFunction::CreateWeakLambda(target, [=]
+ {
+ return target->GetRenderTransform().Translation;
+ }), FLTweenVector2DSetterFunction::CreateUObject(target, &UWidget::SetRenderTranslation)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::UMG_RenderTransform_AngleTo(UObject* WorldContextObject, UWidget* target, float endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject
+ , FLTweenFloatGetterFunction::CreateUObject(target, &UWidget::GetRenderTransformAngle)
+ , FLTweenFloatSetterFunction::CreateUObject(target, &UWidget::SetRenderTransformAngle)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::UMG_RenderTransform_ScaleTo(UObject* WorldContextObject, UWidget* target, const FVector2D& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector2DGetterFunction::CreateWeakLambda(target, [=]
+ {
+ return target->GetRenderTransform().Scale;
+ }), FLTweenVector2DSetterFunction::CreateUObject(target, &UWidget::SetRenderScale)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::UMG_RenderTransform_ShearTo(UObject* WorldContextObject, UWidget* target, const FVector2D& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenVector2DGetterFunction::CreateWeakLambda(target, [=]
+ {
+ return target->GetRenderTransform().Shear;
+ }), FLTweenVector2DSetterFunction::CreateUObject(target, &UWidget::SetRenderShear)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+ULTweener* ULTweenBPLibrary::UMG_RenderOpacityTo(UObject* WorldContextObject, UWidget* target, float endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject
+ , FLTweenFloatGetterFunction::CreateUObject(target, &UWidget::GetRenderOpacity)
+ , FLTweenFloatSetterFunction::CreateUObject(target, &UWidget::SetRenderOpacity)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Blueprint/UserWidget.h"
+ULTweener* ULTweenBPLibrary::UMG_UserWidget_ColorAndOpacityTo(UObject* WorldContextObject, UUserWidget* target, const FLinearColor& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenLinearColorGetterFunction::CreateWeakLambda(target, [=]
+ {
+ return target->GetColorAndOpacity();
+ }), FLTweenLinearColorSetterFunction::CreateUObject(target, &UUserWidget::SetColorAndOpacity)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/Image.h"
+ULTweener* ULTweenBPLibrary::UMG_Image_ColorAndOpacityTo(UObject* WorldContextObject, UImage* target, const FLinearColor& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenLinearColorGetterFunction::CreateWeakLambda(target, [=]
+ {
+ return target->GetColorAndOpacity();
+ }), FLTweenLinearColorSetterFunction::CreateUObject(target, &UImage::SetColorAndOpacity)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/Button.h"
+ULTweener* ULTweenBPLibrary::UMG_Button_ColorAndOpacityTo(UObject* WorldContextObject, UButton* target, const FLinearColor& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject, FLTweenLinearColorGetterFunction::CreateWeakLambda(target, [=]
+ {
+ return target->GetColorAndOpacity();
+ }), FLTweenLinearColorSetterFunction::CreateUObject(target, &UButton::SetColorAndOpacity)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#include "Components/Border.h"
+ULTweener* ULTweenBPLibrary::UMG_Border_ContentColorAndOpacityTo(UObject* WorldContextObject, UBorder* target, const FLinearColor& endValue, float duration, float delay, ELTweenEase ease)
+{
+ if (!IsValid(target))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s] target is not valid:%s"), ANSI_TO_TCHAR(__FUNCTION__), *(target->GetPathName()));
+ return nullptr;
+ }
+ auto Tweener = ULTweenManager::To(WorldContextObject
+ , FLTweenLinearColorGetterFunction::CreateUObject(target, &UBorder::GetContentColorAndOpacity)
+ , FLTweenLinearColorSetterFunction::CreateUObject(target, &UBorder::SetContentColorAndOpacity)
+ , endValue, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->SetEase(ease)->SetAffectByGamePause(false)->SetAffectByTimeDilation(false);
+ }
+ return Tweener;
+}
+#pragma endregion
diff --git a/Plugins/LTween/Source/LTween/Private/LTweenManager.cpp b/Plugins/LTween/Source/LTween/Private/LTweenManager.cpp
new file mode 100644
index 0000000..bab0ff0
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/LTweenManager.cpp
@@ -0,0 +1,493 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#include "LTweenManager.h"
+#include "Tweener/LTweenerFloat.h"
+#include "Tweener/LTweenerDouble.h"
+#include "Tweener/LTweenerInteger.h"
+#include "Tweener/LTweenerVector.h"
+#include "Tweener/LTweenerColor.h"
+#include "Tweener/LTweenerLinearColor.h"
+#include "Tweener/LTweenerVector2D.h"
+#include "Tweener/LTweenerVector4.h"
+#include "Tweener/LTweenerPosition.h"
+#include "Tweener/LTweenerQuaternion.h"
+#include "Tweener/LTweenerRotator.h"
+#include "Tweener/LTweenerRotationEuler.h"
+#include "Tweener/LTweenerRotationQuat.h"
+#include "Tweener/LTweenerMaterialScalar.h"
+#include "Tweener/LTweenerMaterialVector.h"
+
+#include "Tweener/LTweenerFrame.h"
+#include "Tweener/LTweenerVirtual.h"
+#include "Tweener/LTweenerUpdate.h"
+
+#include "LTweenerSequence.h"
+
+#include "Engine/World.h"
+#include "Engine/Engine.h"
+
+ULTweenTickHelperComponent::ULTweenTickHelperComponent()
+{
+ PrimaryComponentTick.bCanEverTick = true;
+ PrimaryComponentTick.bStartWithTickEnabled = true;
+ PrimaryComponentTick.TickGroup = ETickingGroup::TG_DuringPhysics;
+ PrimaryComponentTick.bTickEvenWhenPaused = true;
+}
+void ULTweenTickHelperComponent::BeginPlay()
+{
+ Super::BeginPlay();
+}
+void ULTweenTickHelperComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+ Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+ if (Target.IsValid())
+ {
+ Target->Tick((ELTweenTickType)((uint8)PrimaryComponentTick.TickGroup), DeltaTime);
+ }
+}
+void ULTweenTickHelperComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+ Super::EndPlay(EndPlayReason);
+}
+
+ALTweenTickHelperActor::ALTweenTickHelperActor()
+{
+ PrimaryActorTick.bCanEverTick = true;
+ PrimaryActorTick.bStartWithTickEnabled = true;
+ PrimaryActorTick.TickGroup = ETickingGroup::TG_DuringPhysics;
+ PrimaryActorTick.bTickEvenWhenPaused = true;
+
+ SpawnCollisionHandlingMethod = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+}
+void ALTweenTickHelperActor::BeginPlay()
+{
+ Super::BeginPlay();
+ if (auto LTweenManager = ULTweenManager::GetLTweenInstance(this))
+ {
+ SetupTick(LTweenManager);
+ }
+ else
+ {
+ //If GameInstance subsystem not created yet, then register a event to wait it create
+ OnLTweenManagerCreatedDelegateHandle = ULTweenManager::OnLTweenManagerCreated.AddUObject(this, &ALTweenTickHelperActor::OnLTweenManagerCreated);
+ }
+}
+void ALTweenTickHelperActor::Tick(float DeltaSeconds)
+{
+ Super::Tick(DeltaSeconds);
+ if (Target.IsValid())
+ {
+ Target->Tick(ELTweenTickType::DuringPhysics, DeltaSeconds);
+ }
+}
+void ALTweenTickHelperActor::EndPlay(EEndPlayReason::Type EndPlayReason)
+{
+ Super::EndPlay(EndPlayReason);
+ if (OnLTweenManagerCreatedDelegateHandle.IsValid())
+ {
+ ULTweenManager::OnLTweenManagerCreated.Remove(OnLTweenManagerCreatedDelegateHandle);
+ }
+}
+void ALTweenTickHelperActor::OnLTweenManagerCreated(ULTweenManager* LTweenManager)
+{
+ SetupTick(LTweenManager);
+}
+void ALTweenTickHelperActor::SetupTick(ULTweenManager* LTweenManager)
+{
+ auto CreateComp = [LTweenManager, this](ETickingGroup TickingGroup, FName Name) {
+ auto TickComp_DuringPhysics = NewObject(this, Name);
+ TickComp_DuringPhysics->SetTickGroup(TickingGroup);
+ TickComp_DuringPhysics->RegisterComponent();
+ TickComp_DuringPhysics->Target = LTweenManager;
+ this->AddInstanceComponent(TickComp_DuringPhysics);
+ };
+ CreateComp(ETickingGroup::TG_PrePhysics, TEXT("PrePhysics"));
+ CreateComp(ETickingGroup::TG_PostPhysics, TEXT("PostPhysics"));
+ CreateComp(ETickingGroup::TG_PostUpdateWork, TEXT("PostUpdateWork"));
+ this->Target = LTweenManager;
+}
+
+
+
+bool ULTweenTickHelperWorldSubsystem::ShouldCreateSubsystem(UObject* Outer) const
+{
+ if (auto World = Outer->GetWorld())
+ {
+ if (World->IsGameWorld())
+ {
+ return true;
+ }
+ }
+ return false;
+}
+void ULTweenTickHelperWorldSubsystem::PostInitialize()
+{
+ Super::PostInitialize();
+ if (auto World = GetWorld())
+ {
+ if (World->IsGameWorld())
+ {
+ World->SpawnActor();
+ }
+ }
+}
+
+
+DECLARE_CYCLE_STAT(TEXT("LTween Update"), STAT_Update, STATGROUP_LTween);
+
+FLTweenManagerCreated ULTweenManager::OnLTweenManagerCreated;
+//~USubsystem interface
+void ULTweenManager::Initialize(FSubsystemCollectionBase& Collection)
+{
+ const UGameInstance* LocalGameInstance = GetGameInstance();
+ check(LocalGameInstance);
+}
+
+void ULTweenManager::Deinitialize()
+{
+ tweenerList.Empty();
+}
+
+bool ULTweenManager::ShouldCreateSubsystem(UObject* Outer) const
+{
+ return true;
+}
+//~End of USubsystem interface
+
+void ULTweenManager::Tick(ELTweenTickType TickType, float DeltaTime)
+{
+ if (bTickPaused)return;
+ if (TickType == ELTweenTickType::Manual)
+ {
+ OnTick(TickType, DeltaTime, DeltaTime);
+ }
+ else
+ {
+ if (auto World = GetWorld())
+ {
+ OnTick(TickType, World->DeltaTimeSeconds, World->DeltaRealTimeSeconds);
+ }
+ else
+ {
+ OnTick(TickType, DeltaTime, DeltaTime);
+ }
+ }
+}
+
+#include "Kismet/GameplayStatics.h"
+#include "Engine/GameInstance.h"
+ULTweenManager* ULTweenManager::GetLTweenInstance(UObject* WorldContextObject)
+{
+ if (auto GameInstance = UGameplayStatics::GetGameInstance(WorldContextObject))
+ return GameInstance->GetSubsystem();
+ else
+ return nullptr;
+}
+
+void ULTweenManager::OnTick(ELTweenTickType TickType, float DeltaTime, float UnscaledDeltaTime)
+{
+ SCOPE_CYCLE_COUNTER(STAT_Update);
+
+ auto count = tweenerList.Num();
+ for (int32 i = 0; i < count; i++)
+ {
+ auto tweener = tweenerList[i];
+ if (!IsValid(tweener))
+ {
+ tweenerList.RemoveAt(i);
+ i--;
+ count--;
+ }
+ else
+ {
+ if (tweener->GetTickType() != TickType)continue;
+ if (tweener->ToNext(DeltaTime, UnscaledDeltaTime) == false)
+ {
+ tweenerList.RemoveAt(i);
+ tweener->ConditionalBeginDestroy();
+ i--;
+ count--;
+ }
+ }
+ }
+ if (TickType == ELTweenTickType::DuringPhysics)
+ {
+ if (updateEvent.IsBound())
+ updateEvent.Broadcast(DeltaTime);
+ }
+}
+
+void ULTweenManager::CustomTick(float DeltaTime)
+{
+ OnTick(ELTweenTickType::DuringPhysics, DeltaTime, DeltaTime);
+}
+
+void ULTweenManager::DisableTick()
+{
+ bTickPaused = true;
+}
+void ULTweenManager::EnableTick()
+{
+ bTickPaused = false;
+}
+void ULTweenManager::ManualTick(float DeltaTime)
+{
+ Tick(ELTweenTickType::Manual, DeltaTime);
+}
+void ULTweenManager::KillAllTweens(bool callComplete)
+{
+ for (auto item : tweenerList)
+ {
+ if (IsValid(item))
+ {
+ item->Kill(callComplete);
+ }
+ }
+ tweenerList.Reset();
+}
+bool ULTweenManager::IsTweening(UObject* WorldContextObject, ULTweener* item)
+{
+ if (!IsValid(item))return false;
+
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return false;
+
+ return Instance->tweenerList.Contains(item);
+}
+void ULTweenManager::KillIfIsTweening(UObject* WorldContextObject, ULTweener* item, bool callComplete)
+{
+ if (IsTweening(WorldContextObject, item))
+ {
+ item->Kill(callComplete);
+ }
+}
+void ULTweenManager::RemoveTweener(UObject* WorldContextObject, ULTweener* item)
+{
+ if (!IsValid(item))return;
+
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return;
+ Instance->tweenerList.Remove(item);
+}
+//float
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenFloatGetterFunction& getter, const FLTweenFloatSetterFunction& setter, float endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//float
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenDoubleGetterFunction& getter, const FLTweenDoubleSetterFunction& setter, double endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//interger
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenIntGetterFunction& getter, const FLTweenIntSetterFunction& setter, int endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//position
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenPositionGetterFunction& getter, const FLTweenPositionSetterFunction& setter, const FVector& endValue, float duration, bool sweep, FHitResult* sweepHitResult, ETeleportType teleportType)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration, sweep, sweepHitResult, teleportType);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//vector
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenVectorGetterFunction& getter, const FLTweenVectorSetterFunction& setter, const FVector& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//color
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenColorGetterFunction& getter, const FLTweenColorSetterFunction& setter, const FColor& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//linearcolor
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenLinearColorGetterFunction& getter, const FLTweenLinearColorSetterFunction& setter, const FLinearColor& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//vector2d
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenVector2DGetterFunction& getter, const FLTweenVector2DSetterFunction& setter, const FVector2D& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//vector4
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenVector4GetterFunction& getter, const FLTweenVector4SetterFunction& setter, const FVector4& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//quaternion
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenQuaternionGetterFunction& getter, const FLTweenQuaternionSetterFunction& setter, const FQuat& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//rotator
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenRotatorGetterFunction& getter, const FLTweenRotatorSetterFunction& setter, const FRotator& endValue, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//rotation euler
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenRotationQuatGetterFunction& getter, const FLTweenRotationQuatSetterFunction& setter, const FVector& eulerAngle, float duration, bool sweep, FHitResult* sweepHitResult, ETeleportType teleportType)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, eulerAngle, duration, sweep, sweepHitResult, teleportType);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//rotation quat
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenRotationQuatGetterFunction& getter, const FLTweenRotationQuatSetterFunction& setter, const FQuat& endValue, float duration, bool sweep, FHitResult* sweepHitResult, ETeleportType teleportType)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration, sweep, sweepHitResult, teleportType);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//material scalar
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenMaterialScalarGetterFunction& getter, const FLTweenMaterialScalarSetterFunction& setter, float endValue, float duration, int32 parameterIndex)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration, parameterIndex);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+//material vector
+ULTweener* ULTweenManager::To(UObject* WorldContextObject, const FLTweenMaterialVectorGetterFunction& getter, const FLTweenMaterialVectorSetterFunction& setter, const FLinearColor& endValue, float duration, int32 parameterIndex)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(getter, setter, endValue, duration, parameterIndex);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+
+ULTweener* ULTweenManager::VirtualTo(UObject* WorldContextObject, float duration)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(duration);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+
+ULTweener* ULTweenManager::DelayFrameCall(UObject* WorldContextObject, int delayFrame)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ tweener->SetInitialValue(delayFrame);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+
+ULTweener* ULTweenManager::UpdateCall(UObject* WorldContextObject)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+
+ULTweenerSequence* ULTweenManager::CreateSequence(UObject* WorldContextObject)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return nullptr;
+
+ auto tweener = NewObject(WorldContextObject);
+ Instance->tweenerList.Add(tweener);
+ return tweener;
+}
+
+FDelegateHandle ULTweenManager::RegisterUpdateEvent(UObject* WorldContextObject, const FLTweenUpdateDelegate& update)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return FDelegateHandle();
+
+ return Instance->updateEvent.Add(update);
+}
+void ULTweenManager::UnregisterUpdateEvent(UObject* WorldContextObject, const FDelegateHandle& delegateHandle)
+{
+ auto Instance = GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return;
+
+ Instance->updateEvent.Remove(delegateHandle);
+}
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/LTweener.cpp b/Plugins/LTween/Source/LTween/Private/LTweener.cpp
new file mode 100644
index 0000000..cfa61db
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/LTweener.cpp
@@ -0,0 +1,338 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#include "LTweener.h"
+#include "Curves/CurveFloat.h"
+#include "LTween.h"
+#include "Engine/World.h"
+
+ULTweener::ULTweener()
+{
+ tweenFunc.BindStatic(&ULTweener::OutCubic);//OutCubic default animation curve function
+}
+ULTweener* ULTweener::SetEase(ELTweenEase easetype)
+{
+ if (elapseTime > 0 || startToTween)return this;
+ switch (easetype)
+ {
+ case ELTweenEase::Linear:
+ tweenFunc.BindStatic(&ULTweener::Linear);
+ break;
+ case ELTweenEase::InQuad:
+ tweenFunc.BindStatic(&ULTweener::InQuad);
+ break;
+ case ELTweenEase::OutQuad:
+ tweenFunc.BindStatic(&ULTweener::OutQuad);
+ break;
+ case ELTweenEase::InOutQuad:
+ tweenFunc.BindStatic(&ULTweener::InOutQuad);
+ break;
+ case ELTweenEase::InCubic:
+ tweenFunc.BindStatic(&ULTweener::InCubic);
+ break;
+ case ELTweenEase::OutCubic:
+ tweenFunc.BindStatic(&ULTweener::OutCubic);
+ break;
+ case ELTweenEase::InOutCubic:
+ tweenFunc.BindStatic(&ULTweener::InOutCubic);
+ break;
+ case ELTweenEase::InQuart:
+ tweenFunc.BindStatic(&ULTweener::InQuart);
+ break;
+ case ELTweenEase::OutQuart:
+ tweenFunc.BindStatic(&ULTweener::OutQuart);
+ break;
+ case ELTweenEase::InOutQuart:
+ tweenFunc.BindStatic(&ULTweener::InOutQuart);
+ break;
+ case ELTweenEase::InSine:
+ tweenFunc.BindStatic(&ULTweener::InSine);
+ break;
+ case ELTweenEase::OutSine:
+ tweenFunc.BindStatic(&ULTweener::OutSine);
+ break;
+ case ELTweenEase::InOutSine:
+ tweenFunc.BindStatic(&ULTweener::InOutSine);
+ break;
+ case ELTweenEase::InExpo:
+ tweenFunc.BindStatic(&ULTweener::InExpo);
+ break;
+ case ELTweenEase::OutExpo:
+ tweenFunc.BindStatic(&ULTweener::OutExpo);
+ break;
+ case ELTweenEase::InOutExpo:
+ tweenFunc.BindStatic(&ULTweener::InOutExpo);
+ break;
+ case ELTweenEase::InCirc:
+ tweenFunc.BindStatic(&ULTweener::InCirc);
+ break;
+ case ELTweenEase::OutCirc:
+ tweenFunc.BindStatic(&ULTweener::OutCirc);
+ break;
+ case ELTweenEase::InOutCirc:
+ tweenFunc.BindStatic(&ULTweener::InOutCirc);
+ break;
+ case ELTweenEase::InElastic:
+ tweenFunc.BindStatic(&ULTweener::InElastic);
+ break;
+ case ELTweenEase::OutElastic:
+ tweenFunc.BindStatic(&ULTweener::OutElastic);
+ break;
+ case ELTweenEase::InOutElastic:
+ tweenFunc.BindStatic(&ULTweener::InOutElastic);
+ break;
+ case ELTweenEase::InBack:
+ tweenFunc.BindStatic(&ULTweener::InBack);
+ break;
+ case ELTweenEase::OutBack:
+ tweenFunc.BindStatic(&ULTweener::OutBack);
+ break;
+ case ELTweenEase::InOutBack:
+ tweenFunc.BindStatic(&ULTweener::InOutBack);
+ break;
+ case ELTweenEase::InBounce:
+ tweenFunc.BindStatic(&ULTweener::InBounce);
+ break;
+ case ELTweenEase::OutBounce:
+ tweenFunc.BindStatic(&ULTweener::OutBounce);
+ break;
+ case ELTweenEase::InOutBounce:
+ tweenFunc.BindStatic(&ULTweener::InOutBounce);
+ break;
+ case ELTweenEase::CurveFloat:
+ tweenFunc.BindUObject(this, &ULTweener::CurveFloat);
+ break;
+ }
+ return this;
+}
+ULTweener* ULTweener::SetDelay(float newDelay)
+{
+ if (elapseTime > 0 || startToTween)return this;
+ this->delay = newDelay;
+ if (this->delay < 0)
+ {
+ this->delay = 0;
+ }
+ return this;
+}
+ULTweener* ULTweener::SetLoop(ELTweenLoop newLoopType, int32 newLoopCount)
+{
+ if (elapseTime > 0 || startToTween)return this;
+ this->loopType = newLoopType;
+ this->maxLoopCount = newLoopCount;
+ return this;
+}
+ULTweener* ULTweener::SetEaseCurve(UCurveFloat* newCurve)
+{
+ if (IsValid(newCurve))
+ {
+ SetEase(ELTweenEase::CurveFloat);
+ curveFloat = newCurve;
+ }
+ else
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweener::SetEaseCurve]newCurve is not valid!"));
+ }
+ return this;
+}
+
+ULTweener* ULTweener::SetCurveFloat(UCurveFloat* newCurveFloat)
+{
+ if (elapseTime > 0 || startToTween)return this;
+ curveFloat = newCurveFloat;
+ return this;
+}
+ULTweener* ULTweener::SetAffectByGamePause(bool value)
+{
+ affectByGamePause = value;
+ return this;
+}
+ULTweener* ULTweener::SetAffectByTimeDilation(bool value)
+{
+ affectByTimeDilation = value;
+ return this;
+}
+
+bool ULTweener::ToNext(float deltaTime, float unscaledDeltaTime)
+{
+ if (auto world = GetWorld())
+ {
+ if (world->IsPaused() && affectByGamePause)return true;
+ }
+ if (isMarkedToKill)return false;
+ if (isMarkedPause)return true;//no need to tick time if pause
+ return this->ToNextWithElapsedTime(elapseTime + (affectByTimeDilation ? deltaTime : unscaledDeltaTime));
+}
+bool ULTweener::ToNextWithElapsedTime(float InElapseTime)
+{
+ this->elapseTime = InElapseTime;
+ if (elapseTime > delay)//if elapseTime bigger than delay, do animation
+ {
+ if (!startToTween)
+ {
+ startToTween = true;
+ //set initialize value
+ OnStartGetValue();
+ //execute callback
+ onCycleStartCpp.ExecuteIfBound();
+ onStartCpp.ExecuteIfBound();
+ }
+
+ float elapseTimeWithoutDelay = elapseTime - delay;
+ float currentTime = elapseTimeWithoutDelay - duration * loopCycleCount;
+ if (currentTime >= duration)
+ {
+ bool returnValue = true;
+ loopCycleCount++;
+
+ TweenAndApplyValue(reverseTween ? 0 : duration);
+ onUpdateCpp.ExecuteIfBound(1.0f);
+ onCycleCompleteCpp.ExecuteIfBound();
+ if (loopType == ELTweenLoop::Once)
+ {
+ onCompleteCpp.ExecuteIfBound();
+ returnValue = false;
+ }
+ else if (maxLoopCount <= -1)//infinite loop
+ {
+ onCycleStartCpp.ExecuteIfBound();//start new cycle callback
+ returnValue = true;
+ }
+ else
+ {
+ if (loopCycleCount >= maxLoopCount)//reach end cycle
+ {
+ onCompleteCpp.ExecuteIfBound();
+ returnValue = false;
+ }
+ else//not reach end cycle
+ {
+ onCycleStartCpp.ExecuteIfBound();//start new cycle callback
+ returnValue = true;
+ }
+ }
+ switch (loopType)
+ {
+ case ELTweenLoop::Restart:
+ {
+ SetValueForRestart();
+ }
+ break;
+ case ELTweenLoop::Yoyo:
+ {
+ reverseTween = !reverseTween;
+ SetValueForYoyo();
+ }
+ break;
+ case ELTweenLoop::Incremental:
+ {
+ SetValueForIncremental();
+ }
+ break;
+ }
+ return returnValue;
+ }
+ else
+ {
+ if (reverseTween)
+ {
+ currentTime = duration - currentTime;
+ }
+ TweenAndApplyValue(currentTime);
+ onUpdateCpp.ExecuteIfBound(currentTime / duration);
+ return true;
+ }
+ }
+ else
+ {
+ return true;//waiting delay
+ }
+}
+
+void ULTweener::Kill(bool callComplete)
+{
+ if (callComplete)
+ {
+ onCompleteCpp.ExecuteIfBound();
+ }
+ isMarkedToKill = true;
+}
+
+void ULTweener::ForceComplete()
+{
+ isMarkedToKill = true;
+ elapseTime = delay + duration;
+ TweenAndApplyValue(duration);
+ onUpdateCpp.ExecuteIfBound(1.0f);
+ onCompleteCpp.ExecuteIfBound();
+}
+
+void ULTweener::Restart()
+{
+ if (elapseTime == 0)
+ {
+ return;
+ }
+ isMarkedPause = false;//incase it is paused.
+ //reset parameter to initial
+ loopCycleCount = 0;
+ reverseTween = false;
+ SetOriginValueForRestart();
+
+ this->ToNextWithElapsedTime(0);
+}
+
+void ULTweener::Goto(float timePoint)
+{
+ timePoint = FMath::Clamp(timePoint, 0.0f, duration);
+ //reset parameter to initial
+ loopCycleCount = 0;
+ reverseTween = false;
+
+ this->ToNextWithElapsedTime(timePoint);
+}
+
+float ULTweener::GetProgress()const
+{
+ if (elapseTime > delay)
+ {
+ float elapseTimeWithoutDelay = elapseTime - delay;
+ float currentTime = elapseTimeWithoutDelay - duration * loopCycleCount;
+ if (currentTime >= duration)
+ {
+ return 1;
+ }
+ else
+ {
+ if (reverseTween)
+ {
+ currentTime = duration - currentTime;
+ }
+ return currentTime / duration;
+ }
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+ULTweener* ULTweener::SetTickType(ELTweenTickType value)
+{
+ if (elapseTime > 0 || startToTween)return this;
+ this->tickType = value;
+ return this;
+}
+
+float ULTweener::CurveFloat(float c, float b, float t, float d)
+{
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (curveFloat.IsValid())
+ {
+ return curveFloat->GetFloatValue(t / d) * c + b;
+ }
+ else
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweener::CurveFloat]CurveFloat not valid! Fallback to linear. You should always call SetCurveFloat(and pass a valid curve) if set Easetype to CurveFloat."));
+ return Linear(c, b, t, d);
+ }
+}
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/LTweenerSequence.cpp b/Plugins/LTween/Source/LTween/Private/LTweenerSequence.cpp
new file mode 100644
index 0000000..e154a15
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/LTweenerSequence.cpp
@@ -0,0 +1,326 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#include "LTweenerSequence.h"
+#include "LTween.h"
+#include "LTweenManager.h"
+#include "Tweener/LTweenerFrame.h"
+#include "Tweener/LTweenerVirtual.h"
+
+ULTweenerSequence* ULTweenerSequence::Append(UObject* WorldContextObject, ULTweener* tweener)
+{
+ return this->Insert(WorldContextObject, duration, tweener);
+}
+ULTweenerSequence* ULTweenerSequence::AppendInterval(UObject* WorldContextObject, float interval)
+{
+ if (elapseTime > 0 || startToTween)
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d can't do this because this tween already started"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ duration += interval;
+ return this;
+}
+ULTweenerSequence* ULTweenerSequence::Insert(UObject* WorldContextObject, float timePosition, ULTweener* tweener)
+{
+ if (!IsValid(tweener))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d tweener is null"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweener->IsA() || tweener->IsA())
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d sequence not support this tweener type: %s"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__, *(tweener->GetClass()->GetName()));
+ return this;
+ }
+ if (elapseTime > 0 || startToTween)
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d can't do this because this tween already started"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweenerList.Contains(tweener))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d tweener already contains in the list"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweener->loopType != ELTweenLoop::Once && tweener->maxLoopCount == -1)
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d infinite tweener is not supported in sequence, will convert to 1"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ tweener->maxLoopCount = 1;
+ }
+ ULTweenManager::RemoveTweener(WorldContextObject, tweener);
+ int loopCount = tweener->loopType == ELTweenLoop::Once ? 1 : tweener->maxLoopCount;
+ float tweenerTime = tweener->delay + tweener->duration * loopCount;
+ tweener->SetDelay(tweener->delay + timePosition);
+ tweenerList.Add(tweener);
+ lastTweenStartTime = timePosition;
+ float inputDuration = tweenerTime + timePosition;
+ if (duration < inputDuration)
+ {
+ duration = inputDuration;
+ }
+ return this;
+}
+ULTweenerSequence* ULTweenerSequence::Prepend(UObject* WorldContextObject, ULTweener* tweener)
+{
+ if (!IsValid(tweener))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d tweener is null"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweener->IsA() || tweener->IsA())
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d sequence not support this tweener type: %s"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__, *(tweener->GetClass()->GetName()));
+ return this;
+ }
+ if (elapseTime > 0 || startToTween)
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d can't do this because this tween already started"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweenerList.Contains(tweener))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d tweener already contains in the list"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweener->loopType != ELTweenLoop::Once && tweener->maxLoopCount == -1)
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d infinite tweener is not supported in sequence, will convert to 1"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ tweener->maxLoopCount = 1;
+ }
+ ULTweenManager::RemoveTweener(WorldContextObject, tweener);
+ int loopCount = tweener->loopType == ELTweenLoop::Once ? 1 : tweener->maxLoopCount;
+ float inputDuration = tweener->delay + tweener->duration * loopCount;
+ //offset others
+ for (auto& item : tweenerList)
+ {
+ item->SetDelay(item->delay + inputDuration);
+ }
+ tweenerList.Insert(tweener, 0);
+ duration += inputDuration;
+ lastTweenStartTime = 0;
+ return this;
+}
+ULTweenerSequence* ULTweenerSequence::PrependInterval(UObject* WorldContextObject, float interval)
+{
+ if (elapseTime > 0 || startToTween)
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d can't do this because this tween already started"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ //offset others
+ for (auto& item : tweenerList)
+ {
+ item->SetDelay(item->delay + interval);
+ }
+ duration += interval;
+ lastTweenStartTime += interval;
+ return this;
+}
+ULTweenerSequence* ULTweenerSequence::Join(UObject* WorldContextObject, ULTweener* tweener)
+{
+ if (!IsValid(tweener))
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d tweener is null"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__);
+ return this;
+ }
+ if (tweener->IsA() || tweener->IsA())
+ {
+ UE_LOG(LTween, Error, TEXT("[%s].%d sequence not support this tweener type: %s"), ANSI_TO_TCHAR(__FUNCTION__), __LINE__, *(tweener->GetClass()->GetName()));
+ return this;
+ }
+ if (tweenerList.Num() == 0)return this;
+ return this->Insert(WorldContextObject, lastTweenStartTime, tweener);
+}
+
+void ULTweenerSequence::TweenAndApplyValue(float currentTime)
+{
+ for(int i = 0; i < tweenerList.Num(); i++)
+ {
+ auto& item = tweenerList[i];
+ if (!item->ToNextWithElapsedTime(currentTime))
+ {
+ finishedTweenerList.Add(item);
+ tweenerList.RemoveAt(i);
+ i--;
+ }
+ }
+}
+
+void ULTweenerSequence::SetOriginValueForRestart()
+{
+ for (auto& item : finishedTweenerList)
+ {
+ //add tweener to tweenerList
+ tweenerList.Add(item);
+ }
+ finishedTweenerList.Reset();
+
+ for (auto& item : tweenerList)
+ {
+ if (item->elapseTime > 0 || item->startToTween)
+ {
+ item->SetOriginValueForRestart();//if tween already start, then we can call "SetOriginValueForRestart"
+ item->TweenAndApplyValue(0);
+ }
+ //set parameter to initial
+ item->elapseTime = 0;
+ item->loopCycleCount = 0;
+ item->reverseTween = false;
+ }
+}
+
+void ULTweenerSequence::SetValueForIncremental()
+{
+ for (auto& item : finishedTweenerList)
+ {
+ item->SetValueForIncremental();
+ //set parameter to initial
+ item->elapseTime = 0;
+ item->loopCycleCount = 0;
+ item->reverseTween = false;
+ item->TweenAndApplyValue(0);
+
+ //add tweener to tweenerList
+ tweenerList.Add(item);
+ }
+ finishedTweenerList.Reset();
+}
+void ULTweenerSequence::SetValueForYoyo()
+{
+ this->reverseTween = !this->reverseTween;//reverse it again, so it will keep value false, because we only need to reverse tweenerList
+ for (auto& item : finishedTweenerList)
+ {
+ if (item->loopType != ELTweenLoop::Yoyo)//if it is already yoyo, then we no need to change reverseTween for it
+ {
+ item->reverseTween = !item->reverseTween;
+ }
+
+ //set parameter to initial
+ item->elapseTime = 0;
+ item->loopCycleCount = 0;
+ //flip tweener
+ int loopCount = item->loopType == ELTweenLoop::Once ? 1 : item->maxLoopCount;
+ float tweenerDelay = duration - (item->delay + item->duration * loopCount);
+ item->delay = tweenerDelay;
+
+ //add tweener to tweenerList
+ tweenerList.Add(item);
+ }
+ finishedTweenerList.Reset();
+}
+void ULTweenerSequence::SetValueForRestart()
+{
+ for (auto& item : finishedTweenerList)
+ {
+ //set parameter to initial
+ item->elapseTime = 0;
+ item->loopCycleCount = 0;
+ item->reverseTween = false;
+ item->TweenAndApplyValue(0);
+
+ //add tweener to tweenerList
+ tweenerList.Add(item);
+ }
+ finishedTweenerList.Reset();
+}
+void ULTweenerSequence::Restart()
+{
+ if (elapseTime == 0)
+ {
+ return;
+ }
+ this->isMarkedPause = false;//incase it is paused.
+
+ //reset parameter and value to start
+ {
+ //reset parameter to initial
+ if (this->loopType == ELTweenLoop::Yoyo)
+ {
+ if (loopCycleCount % 2 != 0)//this means current is yoyo back, then we should reverse it
+ {
+ this->reverseTween = true;
+ for (auto& item : tweenerList)
+ {
+ finishedTweenerList.Add(item);
+ }
+ tweenerList.Reset();
+ this->SetValueForYoyo();
+ }
+ }
+ for (auto& item : finishedTweenerList)
+ {
+ tweenerList.Add(item);
+ }
+ finishedTweenerList.Reset();
+ this->loopCycleCount = 0;
+
+ //sort it, so later tweener can do "SetOriginValueForRestart" ealier, so ealier tweener will get correct start state
+ tweenerList.Sort([=](const ULTweener& A, const ULTweener& B) {
+ return A.delay > B.delay;
+ });
+ for (int i = 0; i < tweenerList.Num(); i++)
+ {
+ auto& item = tweenerList[i];
+ if (item->startToTween)
+ {
+ item->SetOriginValueForRestart();
+ item->TweenAndApplyValue(0);
+ }
+ //set parameter to initial
+ item->elapseTime = 0;
+ item->loopCycleCount = 0;
+ item->reverseTween = false;
+ }
+ }
+
+ this->ToNextWithElapsedTime(0);
+}
+void ULTweenerSequence::Goto(float timePoint)
+{
+ timePoint = FMath::Clamp(timePoint, 0.0f, duration);
+
+ //reset parameter to start, then goto timepoint. these line should be same as lines in "Restart"
+ {
+ //reset parameter to initial
+ if (this->loopType == ELTweenLoop::Yoyo)
+ {
+ if (loopCycleCount % 2 != 0)//mean current is yoyo back, should reverse it
+ {
+ this->reverseTween = true;
+ for (auto& item : tweenerList)
+ {
+ finishedTweenerList.Add(item);
+ }
+ tweenerList.Reset();
+ this->SetValueForYoyo();
+ }
+ }
+ for (auto& item : finishedTweenerList)
+ {
+ tweenerList.Add(item);
+ }
+ finishedTweenerList.Reset();
+ this->loopCycleCount = 0;
+
+ //sort it, so later tweener can do "SetOriginValueForRestart" ealier, so ealier tweener will get correct start state
+ tweenerList.Sort([=](const ULTweener& A, const ULTweener& B) {
+ return A.delay > B.delay;
+ });
+ for (int i = 0; i < tweenerList.Num(); i++)
+ {
+ auto& item = tweenerList[i];
+ if (item->startToTween)
+ {
+ item->SetOriginValueForRestart();
+ item->TweenAndApplyValue(0);
+ }
+ //set parameter to initial
+ item->elapseTime = 0;
+ item->loopCycleCount = 0;
+ item->reverseTween = false;
+ }
+ }
+
+ this->ToNextWithElapsedTime(timePoint);
+}
+
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerColor.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerColor.h
new file mode 100644
index 0000000..5553ee7
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerColor.h
@@ -0,0 +1,66 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerColor.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerColor :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FColor startValue;
+ FColor endValue;
+
+ FLTweenColorGetterFunction getter;
+ FLTweenColorSetterFunction setter;
+
+ FColor originStartValue;
+ FColor originEndValue;
+
+ void SetInitialValue(const FLTweenColorGetterFunction& newGetter, const FLTweenColorSetterFunction& newSetter, const FColor& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ this->originEndValue = this->endValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ FColor value;
+ value.R = FMath::Lerp(startValue.R, endValue.R, lerpValue);
+ value.G = FMath::Lerp(startValue.G, endValue.G, lerpValue);
+ value.B = FMath::Lerp(startValue.B, endValue.B, lerpValue);
+ value.A = FMath::Lerp(startValue.A, endValue.A, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ FColor diffValue;
+ diffValue.R = endValue.R - startValue.R;
+ diffValue.G = endValue.G - startValue.G;
+ diffValue.B = endValue.B - startValue.B;
+ diffValue.A = endValue.A - startValue.A;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ startValue = originStartValue;
+ endValue = originEndValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerDouble.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerDouble.h
new file mode 100644
index 0000000..e15e753
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerDouble.h
@@ -0,0 +1,57 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerDouble.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerDouble:public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ double startValue;
+ double endValue;
+
+ FLTweenDoubleGetterFunction getter;
+ FLTweenDoubleSetterFunction setter;
+
+ double originStartValue;
+
+ void SetInitialValue(const FLTweenDoubleGetterFunction& newGetter, const FLTweenDoubleSetterFunction& newSetter, const double& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = FMath::Lerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerFloat.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerFloat.h
new file mode 100644
index 0000000..2b55620
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerFloat.h
@@ -0,0 +1,51 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerFloat.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerFloat:public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startValue = 0.0f;//b
+ float changeValue = 0.0f;//c
+ float endValue = 0.0f;
+
+ FLTweenFloatGetterFunction getter;
+ FLTweenFloatSetterFunction setter;
+
+ float originStartValue = 0.0f;
+
+ void SetInitialValue(const FLTweenFloatGetterFunction& newGetter, const FLTweenFloatSetterFunction& newSetter, float newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->endValue = newEndValue;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ this->changeValue = endValue - startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ auto value = tweenFunc.Execute(changeValue, startValue, currentTime, duration);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ startValue = endValue;
+ endValue += changeValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ startValue = originStartValue;
+ endValue = startValue + changeValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerFrame.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerFrame.h
new file mode 100644
index 0000000..27cd949
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerFrame.h
@@ -0,0 +1,77 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTween.h"
+#include "Engine/World.h"
+#include "LTweenerFrame.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerFrame:public ULTweener
+{
+ GENERATED_BODY()
+public:
+ uint32 startFrameNumber = 0;//b
+ uint32 endFrameNumber = 0;//c
+
+ void SetInitialValue(int newEndValue)
+ {
+ this->startFrameNumber = GFrameNumber;
+ this->endFrameNumber = GFrameNumber + newEndValue;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+
+ }
+ virtual bool ToNext(float deltaTime, float unscaledDeltaTime) override
+ {
+ if (auto world = GetWorld())
+ {
+ if (world->IsPaused() && affectByGamePause)return true;
+ }
+ if (isMarkedToKill)return false;
+ if (isMarkedPause)return true;//no need to tick time if pause
+ if (!startToTween)
+ {
+ startToTween = true;
+ onStartCpp.ExecuteIfBound();
+ }
+
+ if (GFrameNumber >= endFrameNumber)
+ {
+ onUpdateCpp.ExecuteIfBound(1.0f);
+ onCompleteCpp.ExecuteIfBound();
+ return false;
+ }
+ else
+ {
+ onUpdateCpp.ExecuteIfBound((float)(GFrameNumber - startFrameNumber) / (endFrameNumber - startFrameNumber));
+ return true;
+ }
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+
+ }
+ virtual ULTweener* SetDelay(float newDelay)override
+ {
+ UE_LOG(LTween, Error, TEXT("[LTweenerFrame::SetDelay]LTweenerFrame does not support delay!"));
+ return this;
+ }
+ virtual ULTweener* SetLoop(ELTweenLoop newLoopType, int32 newLoopCount)override
+ {
+ UE_LOG(LTween, Error, TEXT("[LTweenerFrame::SetLoop]LTweenerFrame does not support loop!"));
+ return this;
+ }
+ virtual void SetValueForIncremental() override
+ {
+
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto changeValue = endFrameNumber - startFrameNumber;
+ startFrameNumber = GFrameNumber;
+ endFrameNumber = GFrameNumber + changeValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerInteger.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerInteger.h
new file mode 100644
index 0000000..9ef94cc
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerInteger.h
@@ -0,0 +1,53 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerInteger.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerInteger :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ int startValue;
+ int endValue;
+
+ FLTweenIntGetterFunction getter;
+ FLTweenIntSetterFunction setter;
+
+ int originStartValue = 0;
+
+ void SetInitialValue(const FLTweenIntGetterFunction& newGetter, const FLTweenIntSetterFunction& newSetter, int newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ auto lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ setter.ExecuteIfBound(FMath::Lerp(startValue, endValue, lerpValue));
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = GFrameNumber;
+ endValue = GFrameNumber + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerLinearColor.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerLinearColor.h
new file mode 100644
index 0000000..3ebcf29
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerLinearColor.h
@@ -0,0 +1,61 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerLinearColor.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerLinearColor :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FLinearColor startValue;
+ FLinearColor endValue;
+
+ FLTweenLinearColorGetterFunction getter;
+ FLTweenLinearColorSetterFunction setter;
+
+ FLinearColor originStartValue;
+
+ void SetInitialValue(const FLTweenLinearColorGetterFunction& newGetter, const FLTweenLinearColorSetterFunction& newSetter, const FLinearColor& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ FLinearColor value;
+ value.R = FMath::Lerp(startValue.R, endValue.R, lerpValue);
+ value.G = FMath::Lerp(startValue.G, endValue.G, lerpValue);
+ value.B = FMath::Lerp(startValue.B, endValue.B, lerpValue);
+ value.A = FMath::Lerp(startValue.A, endValue.A, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerMaterialScalar.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerMaterialScalar.h
new file mode 100644
index 0000000..76d82fc
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerMaterialScalar.h
@@ -0,0 +1,64 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTween.h"
+#include "LTweenerMaterialScalar.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerMaterialScalar:public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startValue = 0.0f;//b
+ float changeValue = 0.0f;//c
+ int32 parameterIndex;
+ float endValue = 0.0f;
+ FLTweenMaterialScalarGetterFunction getter;
+ FLTweenMaterialScalarSetterFunction setter;
+
+ float originStartValue = 0.0f;
+
+ void SetInitialValue(const FLTweenMaterialScalarGetterFunction& newGetter, const FLTweenMaterialScalarSetterFunction& newSetter, float newEndValue, float newDuration, int32 newParameterIndex)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+ this->parameterIndex = newParameterIndex;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ {
+ if (getter.Execute(startValue))
+ {
+ this->changeValue = endValue - startValue;
+ this->originStartValue = this->changeValue;
+ }
+ else
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenerMaterialScalar/OnStartGetValue]Get paramter value error!"));
+ }
+ }
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ auto value = tweenFunc.Execute(changeValue, startValue, currentTime, duration);
+ if (setter.Execute(parameterIndex, value) == false)
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweenerMaterialScalar/TweenAndApplyValue]Set paramter value error!"));
+ }
+ }
+ virtual void SetValueForIncremental() override
+ {
+ startValue = endValue;
+ endValue += changeValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ startValue = originStartValue;
+ endValue = originStartValue + changeValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerMaterialVector.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerMaterialVector.h
new file mode 100644
index 0000000..5968f1c
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerMaterialVector.h
@@ -0,0 +1,76 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTween.h"
+#include "LTweenerMaterialVector.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerMaterialVector :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FLinearColor startValue;
+ FLinearColor endValue;
+ int32 parameterIndex;
+
+ FLTweenMaterialVectorGetterFunction getter;
+ FLTweenMaterialVectorSetterFunction setter;
+
+ FLinearColor originStartValue;
+
+ void SetInitialValue(const FLTweenMaterialVectorGetterFunction& newGetter, const FLTweenMaterialVectorSetterFunction& newSetter, const FLinearColor& newEndValue, float newDuration, int32 newParameterIndex)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->parameterIndex = newParameterIndex;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ {
+ if (getter.Execute(startValue))
+ {
+ this->originStartValue = startValue;
+ }
+ else
+ {
+ UE_LOG(LTween, Error, TEXT("[ULTweenerMaterialVector/OnStartGetValue]Get paramter value error!"));
+ }
+ }
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ FLinearColor value;
+ value.R = FMath::Lerp(startValue.R, endValue.R, lerpValue);
+ value.G = FMath::Lerp(startValue.G, endValue.G, lerpValue);
+ value.B = FMath::Lerp(startValue.B, endValue.B, lerpValue);
+ value.A = FMath::Lerp(startValue.A, endValue.A, lerpValue);
+ if (setter.IsBound())
+ if (setter.Execute(parameterIndex, value) == false)
+ {
+ UE_LOG(LTween, Warning, TEXT("[ULTweenerMaterialScalar/TweenAndApplyValue]Set paramter value error!"));
+ }
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerPosition.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerPosition.h
new file mode 100644
index 0000000..f1cfff5
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerPosition.h
@@ -0,0 +1,65 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerPosition.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerPosition :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FVector startValue;
+ FVector endValue;
+
+ bool sweep = false;
+ FHitResult* sweepHitResult = nullptr;
+ ETeleportType teleportType = ETeleportType::None;
+
+ FLTweenPositionGetterFunction getter;
+ FLTweenPositionSetterFunction setter;
+
+ FVector originStartValue;
+
+ void SetInitialValue(const FLTweenPositionGetterFunction& newGetter, const FLTweenPositionSetterFunction& newSetter, const FVector& newEndValue, float newDuration, bool newSweep = false, FHitResult* newSweepHitResult = nullptr, ETeleportType newTeleportType = ETeleportType::None)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+
+ this->sweep = newSweep;
+ this->sweepHitResult = newSweepHitResult;
+ this->teleportType = newTeleportType;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ FVector value = FMath::Lerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value, sweep, sweepHitResult, teleportType);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerQuaternion.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerQuaternion.h
new file mode 100644
index 0000000..ffe5d58
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerQuaternion.h
@@ -0,0 +1,57 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerQuaternion.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerQuaternion :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FQuat startValue;
+ FQuat endValue;
+
+ FLTweenQuaternionGetterFunction getter;
+ FLTweenQuaternionSetterFunction setter;
+
+ FQuat originStartValue;
+
+ void SetInitialValue(const FLTweenQuaternionGetterFunction& newGetter, const FLTweenQuaternionSetterFunction& newSetter, const FQuat& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ FQuat value = FQuat::Slerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotationEuler.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotationEuler.h
new file mode 100644
index 0000000..f2f9e52
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotationEuler.h
@@ -0,0 +1,61 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerRotationEuler.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerRotationEuler :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FQuat startValue;
+ FVector eulerAngle;
+
+ bool sweep = false;
+ FHitResult* sweepHitResult = nullptr;
+ ETeleportType teleportType = ETeleportType::None;
+
+ FLTweenRotationQuatGetterFunction getter;
+ FLTweenRotationQuatSetterFunction setter;
+
+ FQuat originStartValue;
+
+ void SetInitialValue(const FLTweenRotationQuatGetterFunction& newGetter, const FLTweenRotationQuatSetterFunction& newSetter, const FVector& newEulerAngle, float newDuration, bool newSweep = false, FHitResult* newSweepHitResult = nullptr, ETeleportType newTeleportType = ETeleportType::None)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->eulerAngle = newEulerAngle;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+
+ this->sweep = newSweep;
+ this->sweepHitResult = newSweepHitResult;
+ this->teleportType = newTeleportType;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = startValue * FQuat::MakeFromEuler(eulerAngle * lerpValue);
+ setter.ExecuteIfBound(value, sweep, sweepHitResult, teleportType);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ startValue = startValue * FQuat::MakeFromEuler(eulerAngle);
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ startValue = originStartValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotationQuat.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotationQuat.h
new file mode 100644
index 0000000..abb4021
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotationQuat.h
@@ -0,0 +1,65 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerRotationQuat.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerRotationQuat :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FQuat startValue;
+ FQuat endValue;
+
+ bool sweep = false;
+ FHitResult* sweepHitResult = nullptr;
+ ETeleportType teleportType = ETeleportType::None;
+
+ FLTweenRotationQuatGetterFunction getter;
+ FLTweenRotationQuatSetterFunction setter;
+
+ FQuat originStartValue;
+
+ void SetInitialValue(const FLTweenRotationQuatGetterFunction& newGetter, const FLTweenRotationQuatSetterFunction& newSetter, const FQuat& newEndValue, float newDuration, bool newSweep = false, FHitResult* newSweepHitResult = nullptr, ETeleportType newTeleportType = ETeleportType::None)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+
+ this->sweep = newSweep;
+ this->sweepHitResult = newSweepHitResult;
+ this->teleportType = newTeleportType;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = FQuat::Slerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value, sweep, sweepHitResult, teleportType);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue * startValue.Inverse();
+ startValue = endValue;
+ endValue = endValue * diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotator.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotator.h
new file mode 100644
index 0000000..513e682
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerRotator.h
@@ -0,0 +1,58 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerRotator.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerRotator :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FRotator startValue;
+ FRotator endValue;
+
+ FLTweenRotatorGetterFunction getter;
+ FLTweenRotatorSetterFunction setter;
+
+ FRotator originStartValue;
+
+ void SetInitialValue(const FLTweenRotatorGetterFunction& newGetter, const FLTweenRotatorSetterFunction& newSetter, const FRotator& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ FRotator value;
+ value = startValue + lerpValue * (endValue - startValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerScale.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerScale.h
new file mode 100644
index 0000000..9c3da47
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerScale.h
@@ -0,0 +1,57 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerScale.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerScale :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FVector startValue;
+ FVector endValue;
+
+ FLTweenVectorGetterFunction getter;
+ FLTweenVectorSetterFunction setter;
+
+ FVector originStartValue;
+
+ void SetInitialValue(const FLTweenVectorGetterFunction& newGetter, const FLTweenVectorSetterFunction& newSetter, const FVector& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = FMath::Lerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerUpdate.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerUpdate.h
new file mode 100644
index 0000000..839b515
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerUpdate.h
@@ -0,0 +1,56 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTween.h"
+#include "Engine/World.h"
+#include "LTweenerUpdate.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerUpdate :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ void SetInitialValue(int newEndValue)
+ {
+
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+
+ }
+ virtual bool ToNext(float deltaTime, float unscaledDeltaTime) override
+ {
+ if (auto world = GetWorld())
+ {
+ if (world->IsPaused() && affectByGamePause)return true;
+ }
+ if (isMarkedToKill)return false;
+ if (isMarkedPause)return true;//no need to tick time if pause
+ onUpdateCpp.ExecuteIfBound(affectByTimeDilation ? deltaTime : unscaledDeltaTime);
+ return true;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+
+ }
+ virtual ULTweener* SetDelay(float newDelay)override
+ {
+ UE_LOG(LTween, Error, TEXT("[LTweenerFrame::SetDelay]LTweenerUpdate does not support delay!"));
+ return this;
+ }
+ virtual ULTweener* SetLoop(ELTweenLoop newLoopType, int32 newLoopCount)override
+ {
+ UE_LOG(LTween, Error, TEXT("[LTweenerFrame::SetLoop]LTweenerUpdate does not support loop!"));
+ return this;
+ }
+ virtual void SetValueForIncremental() override
+ {
+
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector.h
new file mode 100644
index 0000000..228e4ca
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector.h
@@ -0,0 +1,57 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerVector.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerVector :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FVector startValue;
+ FVector endValue;
+
+ FLTweenVectorGetterFunction getter;
+ FLTweenVectorSetterFunction setter;
+
+ FVector originStartValue;
+
+ void SetInitialValue(const FLTweenVectorGetterFunction& newGetter, const FLTweenVectorSetterFunction& newSetter, const FVector& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = FMath::Lerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector2D.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector2D.h
new file mode 100644
index 0000000..141028e
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector2D.h
@@ -0,0 +1,57 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerVector2D.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerVector2D :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FVector2D startValue;
+ FVector2D endValue;
+
+ FLTweenVector2DGetterFunction getter;
+ FLTweenVector2DSetterFunction setter;
+
+ FVector2D originStartValue;
+
+ void SetInitialValue(const FLTweenVector2DGetterFunction& newGetter, const FLTweenVector2DSetterFunction& newSetter, const FVector2D& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = FMath::Lerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector4.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector4.h
new file mode 100644
index 0000000..99130de
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVector4.h
@@ -0,0 +1,57 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerVector4.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerVector4 :public ULTweener
+{
+ GENERATED_BODY()
+public:
+ float startFloat = 0.0f;//b
+ float changeFloat = 1.0f;//c
+ FVector4 startValue;
+ FVector4 endValue;
+
+ FLTweenVector4GetterFunction getter;
+ FLTweenVector4SetterFunction setter;
+
+ FVector4 originStartValue;
+
+ void SetInitialValue(const FLTweenVector4GetterFunction& newGetter, const FLTweenVector4SetterFunction& newSetter, const FVector4& newEndValue, float newDuration)
+ {
+ this->duration = newDuration;
+ this->getter = newGetter;
+ this->setter = newSetter;
+ this->endValue = newEndValue;
+
+ this->startFloat = 0.0f;
+ this->changeFloat = 1.0f;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+ if (getter.IsBound())
+ this->startValue = getter.Execute();
+ this->originStartValue = this->startValue;
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+ float lerpValue = tweenFunc.Execute(changeFloat, startFloat, currentTime, duration);
+ auto value = FMath::Lerp(startValue, endValue, lerpValue);
+ setter.ExecuteIfBound(value);
+ }
+ virtual void SetValueForIncremental() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = endValue;
+ endValue += diffValue;
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+ auto diffValue = endValue - startValue;
+ startValue = originStartValue;
+ endValue = originStartValue + diffValue;
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVirtual.h b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVirtual.h
new file mode 100644
index 0000000..95d5f73
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Private/Tweener/LTweenerVirtual.h
@@ -0,0 +1,34 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerVirtual.generated.h"
+
+UCLASS(NotBlueprintType)
+class LTWEEN_API ULTweenerVirtual:public ULTweener
+{
+ GENERATED_BODY()
+public:
+
+ void SetInitialValue(float newDuration)
+ {
+ this->duration = newDuration;
+ }
+protected:
+ virtual void OnStartGetValue() override
+ {
+
+ }
+ virtual void TweenAndApplyValue(float currentTime) override
+ {
+
+ }
+ virtual void SetValueForIncremental() override
+ {
+
+ }
+ virtual void SetOriginValueForRestart() override
+ {
+
+ }
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Public/LTween.h b/Plugins/LTween/Source/LTween/Public/LTween.h
new file mode 100644
index 0000000..aa11de8
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTween.h
@@ -0,0 +1,15 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "Stats/Stats.h"
+#include "Modules/ModuleInterface.h"
+DECLARE_LOG_CATEGORY_EXTERN(LTween, Log, All);
+DECLARE_STATS_GROUP(TEXT("LTween"), STATGROUP_LTween, STATCAT_Advanced);
+class FLTweenModule : public IModuleInterface
+{
+public:
+
+ /** IModuleInterface implementation */
+ virtual void StartupModule() override;
+ virtual void ShutdownModule() override;
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Public/LTweenBPLibrary.h b/Plugins/LTween/Source/LTween/Public/LTweenBPLibrary.h
new file mode 100644
index 0000000..ea0936c
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTweenBPLibrary.h
@@ -0,0 +1,428 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "LTweenManager.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "LTweenDelegateHandleWrapper.h"
+#include "LTweenBPLibrary.generated.h"
+
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenFloatSetterDynamic, float, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenDoubleSetterDynamic, double, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenIntSetterDynamic, int, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenVector2SetterDynamic, const FVector2D&, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenVector3SetterDynamic, const FVector&, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenVector4SetterDynamic, const FVector4&, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenColorSetterDynamic, const FColor&, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenLinearColorSetterDynamic, const FLinearColor&, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenQuaternionSetterDynamic, const FQuat&, value);
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenRotatorSetterDynamic, const FRotator&, value);
+
+UCLASS()
+class LTWEEN_API ULTweenBPLibrary : public UBlueprintFunctionLibrary
+{
+ GENERATED_BODY()
+
+public:
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* FloatTo(UObject* WorldContextObject, const FLTweenFloatSetterDynamic& setter, float startValue = 0.0f, float endValue = 1.0f, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* DoubleTo(UObject* WorldContextObject, const FLTweenDoubleSetterDynamic& setter, double startValue = 0.0f, double endValue = 1.0f, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* IntTo(UObject* WorldContextObject, const FLTweenIntSetterDynamic& setter, int startValue, int endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* Vector2To(UObject* WorldContextObject, const FLTweenVector2SetterDynamic& setter, FVector2D startValue, FVector2D endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* Vector3To(UObject* WorldContextObject, const FLTweenVector3SetterDynamic& setter, FVector startValue, FVector endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* Vector4To(UObject* WorldContextObject, const FLTweenVector4SetterDynamic& setter, FVector4 startValue, FVector4 endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* ColorTo(UObject* WorldContextObject, const FLTweenColorSetterDynamic& setter, FColor startValue, FColor endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* LinearColorTo(UObject* WorldContextObject, const FLTweenLinearColorSetterDynamic& setter, FLinearColor startValue, FLinearColor endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* QuaternionTo(UObject* WorldContextObject, const FLTweenQuaternionSetterDynamic& setter, FQuat startValue, FQuat endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = "LTween")
+ static ULTweener* RotatorTo(UObject* WorldContextObject, const FLTweenRotatorSetterDynamic& setter, FRotator startValue, FRotator endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+#pragma region PositionXYZ
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position X To"), Category = "LTween")
+ static ULTweener* LocalPositionXTo(USceneComponent* target, double endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position Y To"), Category = "LTween")
+ static ULTweener* LocalPositionYTo(USceneComponent* target, double endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position Z To"), Category = "LTween")
+ static ULTweener* LocalPositionZTo(USceneComponent* target, double endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position X To (Sweep)"), Category = LTween)
+ static ULTweener* LocalPositionXTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position Y To (Sweep)"), Category = LTween)
+ static ULTweener* LocalPositionYTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position Z To (Sweep)"), Category = LTween)
+ static ULTweener* LocalPositionZTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position X To"), Category = "LTween")
+ static ULTweener* WorldPositionXTo(USceneComponent* target, double endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position Y To"), Category = "LTween")
+ static ULTweener* WorldPositionYTo(USceneComponent* target, double endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position Z To"), Category = "LTween")
+ static ULTweener* WorldPositionZTo(USceneComponent* target, double endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position X To (Sweep)"), Category = LTween)
+ static ULTweener* WorldPositionXTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position Y To (Sweep)"), Category = LTween)
+ static ULTweener* WorldPositionYTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position Z To (Sweep)"), Category = LTween)
+ static ULTweener* WorldPositionZTo_Sweep(USceneComponent* target, double endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+#pragma endregion
+
+
+#pragma region Position
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease"), Category = "LTween")
+ static ULTweener* LocalPositionTo(USceneComponent* target, FVector endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Position To (Sweep)"), Category = LTween)
+ static ULTweener* LocalPositionTo_Sweep(USceneComponent* target, FVector endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease"), Category = "LTween")
+ static ULTweener* WorldPositionTo(USceneComponent* target, FVector endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Position To (Sweep)"), Category = LTween)
+ static ULTweener* WorldPositionTo_Sweep(USceneComponent* target, FVector endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+#pragma endregion Position
+
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease"), Category = LTween)
+ static ULTweener* LocalScaleTo(USceneComponent* target, FVector endValue = FVector(1.0f, 1.0f, 1.0f), float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+
+#pragma region Rotation
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", ToolTip = "Rotate eulerAngle relative to current rotation value"), Category = "LTween")
+ static ULTweener* LocalRotateEulerAngleTo(USceneComponent* target, FVector eulerAngle, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", ToolTip = "Rotate absolute quaternion rotation value"), Category = "LTween")
+ static ULTweener* LocalRotationQuaternionTo(USceneComponent* target, const FQuat& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", ToolTip = "Rotate absolute rotator value"), Category = "LTween")
+ static ULTweener* LocalRotatorTo(USceneComponent* target, FRotator endValue, bool shortestPath, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Rotate Euler Angle To (Sweep)", ToolTip = "Rotate eulerAngle relative to current rotation value"), Category = "LTween")
+ static ULTweener* LocalRotateEulerAngleTo_Sweep(USceneComponent* target, FVector eulerAngle, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Rotation Quaternion To (Sweep)", ToolTip = "Rotate absolute quaternion rotation value"), Category = "LTween")
+ static ULTweener* LocalRotationQuaternionTo_Sweep(USceneComponent* target, const FQuat& endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "Local Rotator To (Sweep)", ToolTip = "Rotate absolute rotator value"), Category = "LTween")
+ static ULTweener* LocalRotatorTo_Sweep(USceneComponent* target, FRotator endValue, bool shortestPath, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", ToolTip = "Rotate eulerAngle relative to current rotation value"), Category = "LTween")
+ static ULTweener* WorldRotateEulerAngleTo(USceneComponent* target, FVector eulerAngle, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", ToolTip = "Rotate absolute quaternion rotation value"), Category = "LTween")
+ static ULTweener* WorldRotationQuaternionTo(USceneComponent* target, const FQuat& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", ToolTip = "Rotate absolute rotator value"), Category = "LTween")
+ static ULTweener* WorldRotatorTo(USceneComponent* target, FRotator endValue, bool shortestPath, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Rotate Euler Angle To (Sweep)", ToolTip = "Rotate eulerAngle relative to current rotation value"), Category = "LTween")
+ static ULTweener* WorldRotateEulerAngleTo_Sweep(USceneComponent* target, FVector eulerAngle, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Rotation Quaternion To (Sweep)", ToolTip = "Rotate absolute quaternion rotation value"), Category = "LTween")
+ static ULTweener* WorldRotationQuaternionTo_Sweep(USceneComponent* target, const FQuat& endValue, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", DisplayName = "World Rotator To (Sweep)", ToolTip = "Rotate absolute rotator value"), Category = "LTween")
+ static ULTweener* WorldRotatorTo_Sweep(USceneComponent* target, FRotator endValue, bool shortestPath, FHitResult& sweepHitResult, bool sweep, bool teleport, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+#pragma endregion Rotation
+
+#pragma region Material
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* MaterialScalarParameterTo(UObject* WorldContextObject, class UMaterialInstanceDynamic* target, FName parameterName, float endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* MaterialVectorParameterTo(UObject* WorldContextObject, class UMaterialInstanceDynamic* target, FName parameterName, FLinearColor endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease"), Category = LTween)
+ static ULTweener* MeshMaterialScalarParameterTo(class UPrimitiveComponent* target, int materialIndex, FName parameterName, float endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease"), Category = LTween)
+ static ULTweener* MeshMaterialVectorParameterTo(class UPrimitiveComponent* target, int materialIndex, FName parameterName, FLinearColor endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+#pragma endregion
+
+#pragma region UMG
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_CanvasPanelSlot_PositionTo(UObject* WorldContextObject, class UCanvasPanelSlot* target, const FVector2D& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_CanvasPanelSlot_SizeTo(UObject* WorldContextObject, class UCanvasPanelSlot* target, const FVector2D& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_HorizontalBoxSlot_PaddingTo(UObject* WorldContextObject, class UHorizontalBoxSlot* target, const FMargin& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_VerticalBoxSlot_PaddingTo(UObject* WorldContextObject, class UVerticalBoxSlot* target, const FMargin& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_OverlaySlot_PaddingTo(UObject* WorldContextObject, class UOverlaySlot* target, const FMargin& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_ButtonSlot_PaddingTo(UObject* WorldContextObject, class UButtonSlot* target, const FMargin& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_BorderSlot_PaddingTo(UObject* WorldContextObject, class UBorderSlot* target, const FMargin& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_RenderTransform_TranslationTo(UObject* WorldContextObject, class UWidget* target, const FVector2D& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_RenderTransform_AngleTo(UObject* WorldContextObject, class UWidget* target, float endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_RenderTransform_ScaleTo(UObject* WorldContextObject, class UWidget* target, const FVector2D& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_RenderTransform_ShearTo(UObject* WorldContextObject, class UWidget* target, const FVector2D& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_RenderOpacityTo(UObject* WorldContextObject, class UWidget* target, float endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_UserWidget_ColorAndOpacityTo(UObject* WorldContextObject, class UUserWidget* target, const FLinearColor& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_Image_ColorAndOpacityTo(UObject* WorldContextObject, class UImage* target, const FLinearColor& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_Button_ColorAndOpacityTo(UObject* WorldContextObject, class UButton* target, const FLinearColor& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "delay,ease", WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* UMG_Border_ContentColorAndOpacityTo(UObject* WorldContextObject, class UBorder* target, const FLinearColor& endValue, float duration = 0.5f, float delay = 0.0f, ELTweenEase ease = ELTweenEase::OutCubic);
+#pragma endregion
+
+ UFUNCTION(BlueprintCallable, meta = (ToolTip = "Assign start or update or omplete functions", WorldContext = "WorldContextObject", AutoCreateRefTerm="start,update,complete"), Category = LTween)
+ static ULTweener* VirtualCall(UObject* WorldContextObject, float duration, float delay, const FLTweenerSimpleDynamicDelegate& start, const FLTweenerFloatDynamicDelegate& update, const FLTweenerSimpleDynamicDelegate& complete)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->OnStart(start)->OnUpdate(update)->OnComplete(complete);
+ }
+ return Tweener;
+ }
+ static ULTweener* VirtualCall(UObject* WorldContextObject, float duration, float delay, FSimpleDelegate start, FLTweenUpdateDelegate update, FSimpleDelegate complete)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->OnStart(start)->OnUpdate(update)->OnComplete(complete);
+ };
+ return Tweener;
+ }
+ static ULTweener* VirtualCall(UObject* WorldContextObject, float duration, float delay, const TFunction& start, const TFunction& update, const TFunction& complete)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, duration);
+ if (Tweener)
+ {
+ Tweener->SetDelay(delay)->OnStart(start)->OnUpdate(update)->OnComplete(complete);
+ }
+ return Tweener;
+ }
+ static ULTweener* VirtualCall(UObject* WorldContextObject, float duration)
+ {
+ return ULTweenManager::VirtualTo(WorldContextObject, duration);
+ }
+
+ UFUNCTION(BlueprintCallable, meta = (ToolTip = "MainThread delay call function, Assign delayComplete to call", WorldContext = "WorldContextObject", AdvancedDisplay="affectByGamePause,affectByTimeDilation"), Category = LTween)
+ static ULTweener* DelayCall(UObject* WorldContextObject, float delayTime, const FLTweenerSimpleDynamicDelegate& delayComplete, bool affectByGamePause = true, bool affectByTimeDilation = true)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, delayTime);
+ if (Tweener)
+ {
+ Tweener->OnComplete(delayComplete)->SetAffectByGamePause(affectByGamePause)->SetAffectByTimeDilation(affectByTimeDilation);
+ }
+ return Tweener;
+ }
+ static ULTweener* DelayCall(UObject* WorldContextObject, float delayTime, FSimpleDelegate delayComplete, bool affectByGamePause = true, bool affectByTimeDilation = true)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, delayTime);
+ if (Tweener)
+ {
+ Tweener->OnComplete(delayComplete)->SetAffectByGamePause(affectByGamePause)->SetAffectByTimeDilation(affectByTimeDilation);
+ }
+ return Tweener;
+ }
+ static ULTweener* DelayCall(UObject* WorldContextObject, float delayTime, const TFunction& delayComplete, bool affectByGamePause = true, bool affectByTimeDilation = true)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, delayTime);
+ if (Tweener)
+ {
+ Tweener->OnComplete(delayComplete)->SetAffectByGamePause(affectByGamePause)->SetAffectByTimeDilation(affectByTimeDilation);
+ }
+ return Tweener;
+ }
+ UFUNCTION(BlueprintCallable, meta = (ToolTip = "MainThread delay frame call function, Assign delayComplete to call", WorldContext = "WorldContextObject", AdvancedDisplay = "affectByGamePause"), Category = LTween)
+ static ULTweener* DelayFrameCall(UObject* WorldContextObject, int frameCount, const FLTweenerSimpleDynamicDelegate& delayComplete, bool affectByGamePause = true)
+ {
+ auto Tweener = ULTweenManager::DelayFrameCall(WorldContextObject, frameCount);
+ if (Tweener)
+ {
+ Tweener->OnComplete(delayComplete)->SetAffectByGamePause(affectByGamePause);
+ }
+ return Tweener;
+ }
+ static ULTweener* DelayFrameCall(UObject* WorldContextObject, int frameCount, FSimpleDelegate delayComplete, bool affectByGamePause = true)
+ {
+ auto Tweener = ULTweenManager::DelayFrameCall(WorldContextObject, frameCount);
+ if (Tweener)
+ {
+ Tweener->OnComplete(delayComplete)->SetAffectByGamePause(affectByGamePause);
+ }
+ return Tweener;
+ }
+ static ULTweener* DelayFrameCall(UObject* WorldContextObject, int frameCount, const TFunction& delayComplete, bool affectByGamePause = true)
+ {
+ auto Tweener = ULTweenManager::DelayFrameCall(WorldContextObject, frameCount);
+ if (Tweener)
+ {
+ Tweener->OnComplete(delayComplete)->SetAffectByGamePause(affectByGamePause);
+ }
+ return Tweener;
+ }
+
+ UFUNCTION(BlueprintCallable, meta = (ToolTip = "Assign start or update or omplete functions", WorldContext = "WorldContextObject", AutoCreateRefTerm = "start,update,complete"), Category = LTween)
+ static ULTweener* UpdateCall(UObject* WorldContextObject, const FLTweenerFloatDynamicDelegate& update)
+ {
+ auto Tweener = ULTweenManager::UpdateCall(WorldContextObject);
+ if (Tweener)
+ {
+ Tweener->OnUpdate(update);
+ }
+ return Tweener;
+ }
+ static ULTweener* UpdateCall(UObject* WorldContextObject, FLTweenUpdateDelegate update)
+ {
+ auto Tweener = ULTweenManager::UpdateCall(WorldContextObject);
+ if (Tweener)
+ {
+ Tweener->OnUpdate(update);
+ };
+ return Tweener;
+ }
+ static ULTweener* UpdateCall(UObject* WorldContextObject, const TFunction& update)
+ {
+ auto Tweener = ULTweenManager::UpdateCall(WorldContextObject);
+ if (Tweener)
+ {
+ Tweener->OnUpdate(update);
+ }
+ return Tweener;
+ }
+
+ UFUNCTION(BlueprintPure, Category = LTween, meta = (WorldContext = "WorldContextObject"))
+ static bool IsTweening(UObject* WorldContextObject, ULTweener* inTweener)
+ {
+ return ULTweenManager::IsTweening(WorldContextObject, inTweener);
+ }
+ /**
+ * Force stop this animation. if callComplete = true, OnComplete will call after stop.
+ * This method will check if the tweener is valid.
+ */
+ UFUNCTION(BlueprintCallable, meta = (AdvancedDisplay = "callComplete", WorldContext = "WorldContextObject"), Category = LTween)
+ static void KillIfIsTweening(UObject* WorldContextObject, ULTweener* inTweener, bool callComplete = false)
+ {
+ ULTweenManager::KillIfIsTweening(WorldContextObject, inTweener, callComplete);
+ }
+ UFUNCTION(BlueprintCallable, meta = (DisplayName = "Kill If Is Tweening (Array)", AdvancedDisplay = "callComplete", WorldContext = "WorldContextObject"), Category = LTween)
+ static void ArrayKillIfIsTweening(UObject* WorldContextObject, const TArray& inTweenerArray, bool callComplete = false)
+ {
+ auto Instance = ULTweenManager::GetLTweenInstance(WorldContextObject);
+ if (!IsValid(Instance))return;
+
+ for (auto tweener : inTweenerArray)
+ {
+ Instance->KillIfIsTweening(WorldContextObject, tweener, callComplete);
+ }
+ }
+
+ UE_DEPRECATED(5.2, "Use UpdateCall instead.")
+ static FDelegateHandle RegisterUpdateEvent(UObject* WorldContextObject, const FLTweenUpdateDelegate& update)
+ {
+ // Disable deprecation warnings so we can call the deprecated function to support this function (which is also deprecated)
+ PRAGMA_DISABLE_DEPRECATION_WARNINGS
+ auto delegateHandle = ULTweenManager::RegisterUpdateEvent(WorldContextObject, update);
+ PRAGMA_ENABLE_DEPRECATION_WARNINGS
+ return delegateHandle;
+ }
+ UE_DEPRECATED(5.2, "Use UpdateCall instead.")
+ static FDelegateHandle RegisterUpdateEvent(UObject* WorldContextObject, const TFunction& update)
+ {
+ FLTweenUpdateDelegate updateDelegate = FLTweenUpdateDelegate::CreateLambda(update);
+ // Disable deprecation warnings so we can call the deprecated function to support this function (which is also deprecated)
+ PRAGMA_DISABLE_DEPRECATION_WARNINGS
+ ULTweenManager::RegisterUpdateEvent(WorldContextObject, updateDelegate);
+ PRAGMA_ENABLE_DEPRECATION_WARNINGS
+ return updateDelegate.GetHandle();
+ }
+ UE_DEPRECATED(5.2, "Use UpdateCall instead.")
+ UFUNCTION(BlueprintCallable, meta = (ToolTip = "Registerred update function will be called every frame from mainthread.", WorldContext = "WorldContextObject", DeprecatedFunction, DeprecationMessage = "Use UpdateCall instead."), Category = LTween)
+ static FLTweenDelegateHandleWrapper RegisterUpdateEvent(UObject* WorldContextObject, const FLTweenerFloatDynamicDelegate& update)
+ {
+ FLTweenUpdateDelegate updateDelegate = FLTweenUpdateDelegate::CreateLambda([update](float deltaTime) {update.ExecuteIfBound(deltaTime); });
+ FLTweenDelegateHandleWrapper delegateHandle(updateDelegate.GetHandle());
+ // Disable deprecation warnings so we can call the deprecated function to support this function (which is also deprecated)
+ PRAGMA_DISABLE_DEPRECATION_WARNINGS
+ ULTweenManager::RegisterUpdateEvent(WorldContextObject, updateDelegate);
+ PRAGMA_ENABLE_DEPRECATION_WARNINGS
+ return delegateHandle;
+ }
+ UE_DEPRECATED(5.2, "Use UpdateCall instead of RegisterUpdateEvent, and KillIfIsTweening for returned tweener instead of this UnregisterUpdateEvent.")
+ static void UnregisterUpdateEvent(UObject* WorldContextObject, const FDelegateHandle& handle)
+ {
+ // Disable deprecation warnings so we can call the deprecated function to support this function (which is also deprecated)
+ PRAGMA_DISABLE_DEPRECATION_WARNINGS
+ ULTweenManager::UnregisterUpdateEvent(WorldContextObject, handle);
+ PRAGMA_ENABLE_DEPRECATION_WARNINGS
+ }
+ UE_DEPRECATED(5.2, "Use UpdateCall instead of RegisterUpdateEvent, and KillIfIsTweening for returned tweener instead of this UnregisterUpdateEvent.")
+ UFUNCTION(BlueprintCallable, meta = (ToolTip = "Unregister the update function. \"delegateHandle\" is the return value when use RegisterUpdateEvent.", WorldContext = "WorldContextObject", DeprecatedFunction, DeprecationMessage = "Use UpdateCall instead of RegisterUpdateEvent, and KillIfIsTweening for returned tweener instead of this UnregisterUpdateEvent."), Category = LTween)
+ static void UnregisterUpdateEvent(UObject* WorldContextObject, const FLTweenDelegateHandleWrapper& delegateHandle)
+ {
+ // Disable deprecation warnings so we can call the deprecated function to support this function (which is also deprecated)
+ PRAGMA_DISABLE_DEPRECATION_WARNINGS
+ ULTweenManager::UnregisterUpdateEvent(WorldContextObject, delegateHandle.DelegateHandle);
+ PRAGMA_ENABLE_DEPRECATION_WARNINGS
+ }
+
+ /**
+ * Repeatedly call function.
+ * @param delayTime delay time before the first call
+ * @param interval interval time between every call
+ * @param repeatCount repeat count, -1 means infinite
+ * @return tweener
+ */
+ static ULTweener* RepeatCall(UObject* WorldContextObject, const TFunction& callFunction, float delayTime, float interval, int repeatCount = 1)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, interval);
+ if (Tweener)
+ {
+ Tweener
+ ->SetDelay(delayTime)
+ ->SetLoop(repeatCount == 1 || repeatCount == 0 ? ELTweenLoop::Once : ELTweenLoop::Restart, repeatCount)
+ ->OnCycleStart(callFunction)
+ ;
+ }
+ return Tweener;
+ }
+ /**
+ * Repeatedly call function.
+ * @param delayTime delay time before the first call
+ * @param interval interval time between every call
+ * @param repeatCount repeat count, -1 means infinite
+ * \return tweener
+ */
+ static ULTweener* RepeatCall(UObject* WorldContextObject, const FSimpleDelegate& callFunction, float delayTime, float interval, int repeatCount = 1)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, interval);
+ if (Tweener)
+ {
+ Tweener
+ ->SetDelay(delayTime)
+ ->SetLoop(repeatCount == 1 || repeatCount == 0 ? ELTweenLoop::Once : ELTweenLoop::Restart, repeatCount)
+ ->OnCycleStart(callFunction)
+ ;
+ }
+ return Tweener;
+ }
+ /**
+ * Repeatedly call function.
+ * @param delayTime delay time before the first call
+ * @param interval interval time between every call
+ * @param repeatCount repeat count, -1 means infinite
+ * @return tweener
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ static ULTweener* RepeatCall(UObject* WorldContextObject, FLTweenerSimpleDynamicDelegate callFunction, float delayTime, float interval = 1.0f, int repeatCount = 1)
+ {
+ auto Tweener = ULTweenManager::VirtualTo(WorldContextObject, interval);
+ if (Tweener)
+ {
+ Tweener
+ ->SetDelay(delayTime)
+ ->SetLoop(repeatCount == 1 || repeatCount == 0 ? ELTweenLoop::Once : ELTweenLoop::Restart, repeatCount)
+ ->OnCycleStart(callFunction)
+ ;
+ }
+ return Tweener;
+ }
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ static class ULTweenerSequence* CreateSequence(UObject* WorldContextObject)
+ {
+ return ULTweenManager::CreateSequence(WorldContextObject);
+ }
+};
diff --git a/Plugins/LTween/Source/LTween/Public/LTweenDelegateHandleWrapper.h b/Plugins/LTween/Source/LTween/Public/LTweenDelegateHandleWrapper.h
new file mode 100644
index 0000000..80a42f6
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTweenDelegateHandleWrapper.h
@@ -0,0 +1,19 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "LTweenDelegateHandleWrapper.generated.h"
+
+/** Just a wrapper for blueprint to store a delegate handle */
+USTRUCT(BlueprintType)
+struct LTWEEN_API FLTweenDelegateHandleWrapper
+{
+ GENERATED_BODY()
+public:
+ FLTweenDelegateHandleWrapper() {}
+ FLTweenDelegateHandleWrapper(FDelegateHandle InDelegateHandle)
+ {
+ DelegateHandle = InDelegateHandle;
+ }
+ FDelegateHandle DelegateHandle;
+};
diff --git a/Plugins/LTween/Source/LTween/Public/LTweenHeaders.h b/Plugins/LTween/Source/LTween/Public/LTweenHeaders.h
new file mode 100644
index 0000000..559a4bc
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTweenHeaders.h
@@ -0,0 +1,7 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+
+#include "LTweenManager.h"
+#include "LTweenBPLibrary.h"
+#include "LTweenerSequence.h"
diff --git a/Plugins/LTween/Source/LTween/Public/LTweenManager.h b/Plugins/LTween/Source/LTween/Public/LTweenManager.h
new file mode 100644
index 0000000..ae5f6fc
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTweenManager.h
@@ -0,0 +1,154 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "Components/ActorComponent.h"
+#include "Subsystems/GameInstanceSubsystem.h"
+#include "Subsystems/WorldSubsystem.h"
+#include "LTweener.h"
+#include "LTweenManager.generated.h"
+
+UCLASS(NotBlueprintable, NotBlueprintType, Transient)
+class LTWEEN_API ULTweenTickHelperComponent : public UActorComponent
+{
+ GENERATED_BODY()
+
+public:
+ ULTweenTickHelperComponent();
+ UPROPERTY() TWeakObjectPtr Target = nullptr;
+protected:
+ virtual void BeginPlay() override;
+ virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
+ virtual void EndPlay(const EEndPlayReason::Type EndPlayReason)override;
+};
+
+UCLASS(NotBlueprintable, NotBlueprintType, Transient, NotPlaceable)
+class LTWEEN_API ALTweenTickHelperActor : public AActor
+{
+ GENERATED_BODY()
+
+public:
+ ALTweenTickHelperActor();
+ virtual void BeginPlay()override;
+ virtual void Tick(float DeltaSeconds)override;
+ virtual void EndPlay(EEndPlayReason::Type EndPlayReason)override;
+ UPROPERTY() TWeakObjectPtr Target = nullptr;
+private:
+ void OnLTweenManagerCreated(class ULTweenManager* LTweenManager);
+ FDelegateHandle OnLTweenManagerCreatedDelegateHandle;
+
+ void SetupTick(ULTweenManager* LTweenManager);
+};
+
+// This class is only for spawn ALTweenTickHelperActor for game world
+UCLASS(NotBlueprintable, NotBlueprintType, Transient)
+class LTWEEN_API ULTweenTickHelperWorldSubsystem : public UWorldSubsystem
+{
+ GENERATED_BODY()
+public:
+ virtual bool ShouldCreateSubsystem(UObject* Outer) const override;
+ virtual void PostInitialize()override;
+};
+
+DECLARE_EVENT_OneParam(ULTweenManager, FLTweenManagerCreated, class ULTweenManager*);
+
+UCLASS(NotBlueprintable, BlueprintType, Transient)
+class LTWEEN_API ULTweenManager : public UGameInstanceSubsystem
+{
+ GENERATED_BODY()
+
+public:
+
+ //~USubsystem interface
+ virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+ virtual void Deinitialize() override;
+ virtual bool ShouldCreateSubsystem(UObject* Outer) const override;
+ //~End of USubsystem interface
+
+ //~FTickableObjectBase interface
+ void Tick(ELTweenTickType TickType, float DeltaTime);
+
+ UFUNCTION(BlueprintPure, Category = LTween, meta = (WorldContext = "WorldContextObject", DisplayName = "Get LTween Instance"))
+ static ULTweenManager* GetLTweenInstance(UObject* WorldContextObject);
+ static FLTweenManagerCreated OnLTweenManagerCreated;
+private:
+ /** current active tweener collection*/
+ UPROPERTY(VisibleAnywhere, Category=LTween)TArray> tweenerList;
+ void OnTick(ELTweenTickType TickType, float DeltaTime, float UnscaledDeltaTime);
+ FLTweenUpdateMulticastDelegate updateEvent;
+ bool bTickPaused = false;
+public:
+ UE_DEPRECATED(5.1, "Use Tweener->SetTickType(ELTweenTickType::Manual) then call this->ManualTick.")
+ /** Use "CustomTick" instead of UE4's default Tick to control your tween animations. Call "DisableTick" function to disable UE4's default Tick function, then call this CustomTick function.*/
+ UFUNCTION(BlueprintCallable, Category = LTween, meta=(DeprecatedFunction, DeprecationMessage = "Use Tweener->SetTickType(ELTweenTickType::Manual) then call this->ManualTick."))
+ void CustomTick(float DeltaTime);
+ UE_DEPRECATED(5.1, "Use Tweener->SetTickType(ELTweenTickType::Manual) then call this->ManualTick.")
+ /**
+ * Disable default Tick function, so you can pause all tween or use CustomTick to do your own tick and use your own DeltaTime.
+ * This will only pause the tick with current LTweenManager instance, so after load a new level, default Tick will work again, and you need to call DisableTick again if you want to disable tick.
+ */
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (DeprecatedFunction, DeprecationMessage = "Use Tweener->SetTickType(ELTweenTickType::Manual) then call this->ManualTick."))
+ void DisableTick();
+ UE_DEPRECATED(5.1, "Use Tweener->SetTickType(ELTweenTickType::Manual) then call this->ManualTick.")
+ /**
+ * Enable default Tick if it is disabled.
+ */
+ UFUNCTION(BlueprintCallable, Category = LTween, meta = (DeprecatedFunction, DeprecationMessage = "Use Tweener->SetTickType(ELTweenTickType::Manual) then call this->ManualTick."))
+ void EnableTick();
+
+
+ UFUNCTION(BlueprintCallable, Category = LTween)
+ void ManualTick(float DeltaTime);
+
+ /**
+ * Kill all tweens
+ */
+ UFUNCTION(BlueprintCallable, Category = LTween)
+ void KillAllTweens(bool callComplete = false);
+
+ /**
+ * Is the tweener is currently tweening?
+ * @param item tweener item
+ */
+ static bool IsTweening(UObject* WorldContextObject, ULTweener* item);
+ /**
+ * Kill the tweener if it is tweening.
+ * @param item tweener item
+ * @param callComplete true-execute onComplete event.
+ */
+ static void KillIfIsTweening(UObject* WorldContextObject, ULTweener* item, bool callComplete);
+ /**
+ * Remove tweener from list, so the tweener will not be managed by this LTweenManager.
+ * @param item tweener item
+ */
+ static void RemoveTweener(UObject* WorldContextObject, ULTweener* item);
+
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenFloatGetterFunction& getter, const FLTweenFloatSetterFunction& setter, float endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenDoubleGetterFunction& getter, const FLTweenDoubleSetterFunction& setter, double endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenIntGetterFunction& getter, const FLTweenIntSetterFunction& setter, int endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenPositionGetterFunction& getter, const FLTweenPositionSetterFunction& setter, const FVector& endValue, float duration, bool sweep = false, FHitResult* sweepHitResult = nullptr, ETeleportType teleportType = ETeleportType::None);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenVectorGetterFunction& getter, const FLTweenVectorSetterFunction& setter, const FVector& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenColorGetterFunction& getter, const FLTweenColorSetterFunction& setter, const FColor& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenLinearColorGetterFunction& getter, const FLTweenLinearColorSetterFunction& setter, const FLinearColor& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenVector2DGetterFunction& getter, const FLTweenVector2DSetterFunction& setter, const FVector2D& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenVector4GetterFunction& getter, const FLTweenVector4SetterFunction& setter, const FVector4& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenQuaternionGetterFunction& getter, const FLTweenQuaternionSetterFunction& setter, const FQuat& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenRotatorGetterFunction& getter, const FLTweenRotatorSetterFunction& setter, const FRotator& endValue, float duration);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenRotationQuatGetterFunction& getter, const FLTweenRotationQuatSetterFunction& setter, const FVector& eulerAngle, float duration, bool sweep = false, FHitResult* sweepHitResult = nullptr, ETeleportType teleportType = ETeleportType::None);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenRotationQuatGetterFunction& getter, const FLTweenRotationQuatSetterFunction& setter, const FQuat& endValue, float duration, bool sweep = false, FHitResult* sweepHitResult = nullptr, ETeleportType teleportType = ETeleportType::None);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenMaterialScalarGetterFunction& getter, const FLTweenMaterialScalarSetterFunction& setter, float endValue, float duration, int32 parameterIndex);
+ static ULTweener* To(UObject* WorldContextObject, const FLTweenMaterialVectorGetterFunction& getter, const FLTweenMaterialVectorSetterFunction& setter, const FLinearColor& endValue, float duration, int32 parameterIndex);
+
+ static ULTweener* VirtualTo(UObject* WorldContextObject, float duration);
+ static ULTweener* DelayFrameCall(UObject* WorldContextObject, int delayFrame);
+ static ULTweener* UpdateCall(UObject* WorldContextObject);
+
+ static class ULTweenerSequence* CreateSequence(UObject* WorldContextObject);
+
+ UE_DEPRECATED(5.2, "Use LTweenBPLibrary.UpdateCall instead.")
+ static FDelegateHandle RegisterUpdateEvent(UObject* WorldContextObject, const FLTweenUpdateDelegate& update);
+ UE_DEPRECATED(5.2, "Use LTweenBPLibrary.UpdateCall instead of RegisterUpdateEvent, and KillIfIsTweening for returned tweener instead of this UnregisterUpdateEvent.")
+ static void UnregisterUpdateEvent(UObject* WorldContextObject, const FDelegateHandle& delegateHandle);
+};
diff --git a/Plugins/LTween/Source/LTween/Public/LTweener.h b/Plugins/LTween/Source/LTween/Public/LTweener.h
new file mode 100644
index 0000000..32e73e4
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTweener.h
@@ -0,0 +1,701 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/EngineTypes.h"
+#include "Engine/EngineBaseTypes.h"
+#include "Engine/HitResult.h"
+#include "LTweener.generated.h"
+
+DECLARE_DELEGATE_RetVal_FourParams(float, FLTweenFunction, float, float, float, float);
+
+DECLARE_DELEGATE_OneParam(FLTweenUpdateDelegate, float);
+DECLARE_MULTICAST_DELEGATE_OneParam(FLTweenUpdateMulticastDelegate, float);
+
+#ifndef LTweenUpdateDelegate
+#define LTweenUpdateDelegate UE_DEPRECATED_MACRO(5.0, "LTweenUpdateDelegate has been renamed to FLTweenUpdateDelegate") FLTweenUpdateDelegate
+#endif
+#ifndef LTweenUpdateMulticastDelegate
+#define LTweenUpdateMulticastDelegate UE_DEPRECATED_MACRO(5.0, "LTweenUpdateMulticastDelegate has been renamed to FLTweenUpdateMulticastDelegate") FLTweenUpdateMulticastDelegate
+#endif
+
+DECLARE_DELEGATE_RetVal(float, FLTweenFloatGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenFloatSetterFunction, float);
+
+DECLARE_DELEGATE_RetVal(double, FLTweenDoubleGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenDoubleSetterFunction, double);
+
+DECLARE_DELEGATE_RetVal(int, FLTweenIntGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenIntSetterFunction, int);
+
+DECLARE_DELEGATE_RetVal(FVector, FLTweenVectorGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenVectorSetterFunction, FVector);
+
+DECLARE_DELEGATE_RetVal(FColor, FLTweenColorGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenColorSetterFunction, FColor);
+
+DECLARE_DELEGATE_RetVal(FLinearColor, FLTweenLinearColorGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenLinearColorSetterFunction, FLinearColor);
+
+DECLARE_DELEGATE_RetVal(FVector2D, FLTweenVector2DGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenVector2DSetterFunction, FVector2D);
+
+DECLARE_DELEGATE_RetVal(FVector4, FLTweenVector4GetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenVector4SetterFunction, FVector4);
+
+DECLARE_DELEGATE_RetVal(FQuat, FLTweenQuaternionGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenQuaternionSetterFunction, const FQuat&);
+
+DECLARE_DELEGATE_RetVal(FRotator, FLTweenRotatorGetterFunction);
+DECLARE_DELEGATE_OneParam(FLTweenRotatorSetterFunction, FRotator);
+
+DECLARE_DELEGATE_RetVal(FVector, FLTweenPositionGetterFunction);
+DECLARE_DELEGATE_FourParams(FLTweenPositionSetterFunction, FVector, bool, FHitResult*, ETeleportType);
+
+DECLARE_DELEGATE_RetVal(FQuat, FLTweenRotationQuatGetterFunction);
+DECLARE_DELEGATE_FourParams(FLTweenRotationQuatSetterFunction, const FQuat&, bool, FHitResult*, ETeleportType);
+
+DECLARE_DELEGATE_RetVal_OneParam(bool, FLTweenMaterialScalarGetterFunction, float&);
+DECLARE_DELEGATE_RetVal_TwoParams(bool, FLTweenMaterialScalarSetterFunction, int32, float);
+
+DECLARE_DELEGATE_RetVal_OneParam(bool, FLTweenMaterialVectorGetterFunction, FLinearColor&);
+DECLARE_DELEGATE_RetVal_TwoParams(bool, FLTweenMaterialVectorSetterFunction, int32, const FLinearColor&);
+
+/** simple delegate */
+DECLARE_DYNAMIC_DELEGATE(FLTweenerSimpleDynamicDelegate);
+/** @param InProgress Progress of this tween, from 0 to 1 */
+DECLARE_DYNAMIC_DELEGATE_OneParam(FLTweenerFloatDynamicDelegate, float, InProgress);
+
+/** */
+UENUM(BlueprintType, Category = LTween)
+enum class ELTweenTickType:uint8
+{
+ PrePhysics = ETickingGroup::TG_PrePhysics UMETA(DisplayName = "Pre Physics"),
+ DuringPhysics = ETickingGroup::TG_DuringPhysics UMETA(DisplayName = "During Physics"),
+ PostPhysics = ETickingGroup::TG_PostPhysics UMETA(DisplayName = "Post Physics"),
+ PostUpdateWork = ETickingGroup::TG_PostUpdateWork UMETA(DisplayName = "Post Update Work"),
+ /** This tween will use manual tick. You need to call LTweenManager::ManualTick to make it work. */
+ Manual,
+};
+
+/**
+ * Animation curve type
+ */
+UENUM(BlueprintType, Category = LTween)
+enum class ELTweenEase :uint8
+{
+ Linear,
+ InQuad,
+ OutQuad,
+ InOutQuad,
+ InCubic,
+ OutCubic,
+ InOutCubic,
+ InQuart,
+ OutQuart,
+ InOutQuart,
+ InSine,
+ OutSine,
+ InOutSine,
+ InExpo,
+ OutExpo,
+ InOutExpo,
+ InCirc,
+ OutCirc,
+ InOutCirc,
+ InElastic,
+ OutElastic,
+ InOutElastic,
+ InBack,
+ OutBack,
+ InOutBack,
+ InBounce,
+ OutBounce,
+ InOutBounce,
+ /** Use CurveFloat to animate, only range 0-1 is valid. If use this you must assign curveFloat, or fallback to Linear. */
+ CurveFloat,
+};
+
+#ifndef LTweenEase
+#define LTweenEase UE_DEPRECATED_MACRO(5.0, "LTweenEase has been renamed to ELTweenEase") ELTweenEase
+#endif
+
+/**
+ * Loop type
+ */
+UENUM(BlueprintType, Category = LGUI)
+enum class ELTweenLoop :uint8
+{
+ /** Play once, not loop */
+ Once,
+ /** Each loop cycle restarts from beginning */
+ Restart,
+ /** The tween move forward and backward at alternate cycles */
+ Yoyo,
+ /** Continuously increments the tween at the end of each loop cycle (A to B, B to B+(A-B), and so on). */
+ Incremental,
+};
+
+#ifndef LTweenLoop
+#define LTweenLoop UE_DEPRECATED_MACRO(5.0, "LTweenLoop has been renamed to ELTweenLoop") ELTweenLoop
+#endif
+
+class UCurveFloat;
+
+/** Class for manage single tween */
+UCLASS(BlueprintType, Abstract)
+class LTWEEN_API ULTweener : public UObject
+{
+ GENERATED_BODY()
+
+public:
+ ULTweener();
+
+protected:
+ friend class ULTweenerSequence;
+ /** animation duration */
+ float duration = 0.0f;
+ /** delay time before animation start */
+ float delay = 0.0f;
+ /** total elapse time, include delay */
+ float elapseTime = 0.0f;
+ /** use CurveFloat as animation function,horizontal is time (0-1),vertical is value (0-1) */
+ TWeakObjectPtr curveFloat = nullptr;
+ /** loop type */
+ ELTweenLoop loopType = ELTweenLoop::Once;
+ /** max loop count when loop type is Restart/Yoyo/Incremental */
+ int32 maxLoopCount = 0;
+ /** current completed cycle count */
+ int32 loopCycleCount = 0;
+ /** how this tween update */
+ ELTweenTickType tickType = ELTweenTickType::DuringPhysics;
+
+ /** reverse animation */
+ bool reverseTween = false;
+ /** if animation start play */
+ bool startToTween = false;
+ /** mark this tween for kill, so when the next update came, the tween will be killed */
+ bool isMarkedToKill = false;
+ /** mark this tween as pause, it will keep pause until call Resume() */
+ bool isMarkedPause = false;
+ /** will this tween be affected when GamePause? usually set to false for UI */
+ bool affectByGamePause = true;
+ /** will this tween use dilation-time or real-time? */
+ bool affectByTimeDilation = true;
+
+ /** tween function */
+ FLTweenFunction tweenFunc;
+
+ /** call once after animation complete */
+ FSimpleDelegate onCompleteCpp;
+ /** if use loop, this will call every time when begin tween in every cycle */
+ FSimpleDelegate onCycleStartCpp;
+ /** if use loop, this will call every time after tween complete in every cycle */
+ FSimpleDelegate onCycleCompleteCpp;
+ /** call every frame after animation starts */
+ FLTweenUpdateDelegate onUpdateCpp;
+ /** call once when animation starts */
+ FSimpleDelegate onStartCpp;
+public:
+ /**
+ * Set animation curve type.
+ * Has no effect if the Tween has already started.
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* SetEase(ELTweenEase easetype);
+ /** set ease to CurveFloat and use CurveFloat as animation function, horizontal is time (0-1),vertical is value (0-1) */
+ UE_DEPRECATED(4.23, "SetEaseCurve is not valid anymore, use SetEase and SetCurveFloat instead.")
+ UFUNCTION(BlueprintCallable, Category = "LTween", meta = (DeprecatedFunction, DeprecationMessage = "SetEaseCurve is not valid anymore, use SetEase and SetCurveFloat instead."))
+ ULTweener* SetEaseCurve(UCurveFloat* newCurve);
+ /**
+ * Set delay time before start animation.
+ * Has no effect if the Tween has already started.
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual ULTweener* SetDelay(float newDelay);
+ UE_DEPRECATED(4.23, "SetLoopType not valid anymore, use SetLoop instead.")
+ UFUNCTION(BlueprintCallable, Category = "LTween", meta = (DeprecatedFunction, DeprecationMessage = "SetLoopType not valid anymore, use SetLoop instead."))
+ virtual ULTweener* SetLoopType(ELTweenLoop newLoopType)
+ {
+ return SetLoop(newLoopType, -1);
+ }
+ /**
+ * Set loop of tween.
+ * Has no effect if the Tween has already started.
+ * @param newLoopType loop type
+ * @param newLoopCount number of cycles to play (-1 for infinite)
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual ULTweener* SetLoop(ELTweenLoop newLoopType, int32 newLoopCount = 1);
+ UE_DEPRECATED(4.23, "GetLoopCount not valid anymore, use GetLoopCycleCount instead.")
+ UFUNCTION(BlueprintCallable, Category = "LTween", meta = (DeprecatedFunction, DeprecationMessage = "GetLoopCount not valid anymore, use GetLoopCycleCount instead."))
+ int32 GetLoopCount() { return loopCycleCount; }
+ /** curently completed loop cycle count */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ int32 GetLoopCycleCount()const { return loopCycleCount; }
+
+ /** execute when animation complete */
+ ULTweener* OnComplete(const FSimpleDelegate& newComplete)
+ {
+ this->onCompleteCpp = newComplete;
+ return this;
+ }
+ /** execute when animation complete */
+ ULTweener* OnComplete(const TFunction& newComplete)
+ {
+ if (newComplete != nullptr)
+ {
+ this->onCompleteCpp.BindLambda(newComplete);
+ }
+ return this;
+ }
+ /** execute when animation complete */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* OnComplete(const FLTweenerSimpleDynamicDelegate& newComplete)
+ {
+ this->onCompleteCpp.BindLambda([newComplete] {
+ newComplete.ExecuteIfBound();
+ });
+ return this;
+ }
+
+ /** if use loop, this will call every time after tween complete in every cycle */
+ ULTweener* OnCycleComplete(const FSimpleDelegate& newCycleComplete)
+ {
+ this->onCycleCompleteCpp = newCycleComplete;
+ return this;
+ }
+ /** if use loop, this will call every time after tween complete in every cycle */
+ ULTweener* OnCycleComplete(const TFunction& newCycleComplete)
+ {
+ if (newCycleComplete != nullptr)
+ {
+ this->onCycleCompleteCpp.BindLambda(newCycleComplete);
+ }
+ return this;
+ }
+ /** if use loop, this will call every time after tween complete in every cycle */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* OnCycleComplete(const FLTweenerSimpleDynamicDelegate& newCycleComplete)
+ {
+ this->onCycleCompleteCpp.BindLambda([newCycleComplete] {
+ newCycleComplete.ExecuteIfBound();
+ });
+ return this;
+ }
+
+ /** if use loop, this will call every time when begin tween in every cycle */
+ ULTweener* OnCycleStart(const FSimpleDelegate& newCycleStart)
+ {
+ this->onCycleStartCpp = newCycleStart;
+ return this;
+ }
+ /** if use loop, this will call every time when begin tween in every cycle */
+ ULTweener* OnCycleStart(const TFunction& newCycleStart)
+ {
+ if (newCycleStart != nullptr)
+ {
+ this->onCycleStartCpp.BindLambda(newCycleStart);
+ }
+ return this;
+ }
+ /** if use loop, this will call every time when begin tween in every cycle */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* OnCycleStart(const FLTweenerSimpleDynamicDelegate& newCycleStart)
+ {
+ this->onCycleStartCpp.BindLambda([newCycleStart] {
+ newCycleStart.ExecuteIfBound();
+ });
+ return this;
+ }
+
+ /** execute every frame if animation is playing */
+ ULTweener* OnUpdate(const FLTweenUpdateDelegate& newUpdate)
+ {
+ this->onUpdateCpp = newUpdate;
+ return this;
+ }
+ /** execute every frame if animation is playing */
+ ULTweener* OnUpdate(const TFunction& newUpdate)
+ {
+ if (newUpdate != nullptr)
+ {
+ this->onUpdateCpp.BindLambda(newUpdate);
+ }
+ return this;
+ }
+ /** execute every frame if animation is playing */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* OnUpdate(const FLTweenerFloatDynamicDelegate& newUpdate)
+ {
+ this->onUpdateCpp.BindLambda([newUpdate](float progress) {
+ newUpdate.ExecuteIfBound(progress);
+ });
+ return this;
+ }
+
+ /** execute when animation start*/
+ ULTweener* OnStart(const FSimpleDelegate& newStart)
+ {
+ this->onStartCpp = newStart;
+ return this;
+ }
+ /** execute when animation start, blueprint version*/
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* OnStart(const FLTweenerSimpleDynamicDelegate& newStart)
+ {
+ this->onStartCpp.BindLambda([newStart] {
+ newStart.ExecuteIfBound();
+ });
+ return this;
+ }
+ /** execute when animation start, lambda version*/
+ ULTweener* OnStart(const TFunction& newStart)
+ {
+ if (newStart != nullptr)
+ {
+ this->onStartCpp.BindLambda(newStart);
+ }
+ return this;
+ }
+ /**
+ * Set CurveFloat as animation curve. Make sure ease type is CurveFloat. (Call SetEase function to set ease type)
+ * Has no effect if the Tween has already started.
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* SetCurveFloat(UCurveFloat* newCurveFloat);
+ /**
+ * @return false: the tween is complete and need to be killed. true: the tween is still processing.
+ */
+ virtual bool ToNext(float deltaTime, float unscaledDeltaTime);
+ /**
+ * @return false: the tween is complete and need to be killed. true: the tween is still processing.
+ */
+ bool ToNextWithElapsedTime(float InElapseTime);
+ /** Force stop this animation. if callComplete = true, will call OnComplete after stop*/
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual void Kill(bool callComplete = false);
+ /** Force stop this animation at this frame, set value to end, call OnComplete. */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual void ForceComplete();
+ /** Pause this animation. */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ void Pause()
+ {
+ isMarkedPause = true;
+ }
+ /** Continue play animation if is paused. */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ void Resume()
+ {
+ isMarkedPause = false;
+ }
+ /** Will this tween be affected when GamePause? Default is true, usually set to false for UI. */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ bool GetAffectByGamePause()const { return affectByGamePause; }
+ /** Will this tween be affected when GamePause? Default is true, usually set to false for UI. */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* SetAffectByGamePause(bool value);
+ /** will this tween use dilated-time or real-time? */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ bool GetAffectByTimeDilation()const { return affectByTimeDilation; }
+ /** will this tween use dilated-time or real-time? */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* SetAffectByTimeDilation(bool value);
+ /**
+ * Restart animation.
+ * Has no effect if the Tween is not started.
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual void Restart();
+ /**
+ * Send the tween to the given position in time.
+ * @param timePoint Time position to reach (if higher than the whole tween duration the tween will simply reach its end).
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual void Goto(float timePoint);
+ /** Return progress 0-1 */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ virtual float GetProgress()const;
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ float GetElapsedTime()const { return elapseTime; }
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ float GetDuration()const { return duration; }
+
+ /** Return tickType of this tween, default is DuringPhysics. */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ELTweenTickType GetTickType()const { return tickType; }
+ /**
+ * Set TickType of this tween.
+ * Has no effect if the Tween has already started.
+ */
+ UFUNCTION(BlueprintCallable, Category = "LTween")
+ ULTweener* SetTickType(ELTweenTickType value = ELTweenTickType::DuringPhysics);
+protected:
+ /** get value when start. child class must override this, check LTweenerFloat for reference */
+ virtual void OnStartGetValue() PURE_VIRTUAL(ULTweener::OnStartGetValue, );
+ /** set value when tweening. child class must override this, check LTweenerFloat for reference */
+ virtual void TweenAndApplyValue(float currentTime) PURE_VIRTUAL(ULTweener::TweenAndApplyValue, );
+ /** set start and end value if looptype is Incremental. */
+ virtual void SetValueForIncremental() PURE_VIRTUAL(ULTweener::SetValueForIncremental, );
+ /** set start and end value before the animation wan't to restart */
+ virtual void SetOriginValueForRestart() PURE_VIRTUAL(ULTweener::SetOriginValueForRestart, );
+ virtual void SetValueForYoyo() {};
+ virtual void SetValueForRestart() {};
+#pragma region tweenFunctions
+public:
+ /**
+ * @param c Change needed in value.
+ * @param b Starting value.
+ * @param t Current time (in frames or seconds).
+ * @param d Expected eaSing duration (in frames or seconds).
+ * @return The correct value.
+ */
+ static float Linear(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return c*t / d + b;
+ }
+ static float InQuad(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d;
+ return c*t*t + b;
+ }
+ static float OutQuad(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d;
+ return -c*t*(t - 2) + b;
+ }
+ static float InOutQuad(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d * 0.5f;
+ if (t < 1)
+ {
+ return c * 0.5f * t*t + b;
+ }
+ else
+ {
+ --t;
+ return -c * 0.5f * (t*(t - 2) - 1) + b;
+ }
+ }
+ static float InCubic(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d;
+ return c*t*t*t + b;
+ }
+ static float OutCubic(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t = t / d - 1.0f;
+ return c*(t*t*t + 1) + b;
+ }
+ static float InOutCubic(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d * 0.5f;
+ if (t < 1)
+ {
+ return c * 0.5f * t*t*t + b;
+ }
+ else
+ {
+ t -= 2;
+ return c * 0.5f * (t*t*t + 2) + b;
+ }
+ }
+ static float InQuart(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d;
+ return c*t*t*t*t + b;
+ }
+ static float OutQuart(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t = t / d - 1.0f;
+ return -c * (t*t*t*t - 1) + b;
+ }
+ static float InOutQuart(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d * 0.5f;
+ if (t < 1)
+ {
+ return c * 0.5f * t*t*t*t + b;
+ }
+ else
+ {
+ t -= 2;
+ return -c * 0.5f * (t*t*t*t - 2) + b;
+ }
+ }
+ static float InSine(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return -c * FMath::Cos(t / d * HALF_PI) + c + b;
+ }
+ static float OutSine(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return c * FMath::Sin(t / d * HALF_PI) + b;
+ }
+ static float InOutSine(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return -c * 0.5f * (FMath::Cos(PI * t / d) - 1) + b;
+ }
+ static float InExpo(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return (t == 0.0f) ? b : c * FMath::Pow(2.0f, 10.0f * (t / d - 1.0f)) + b - c * 0.001f;
+ }
+ static float OutExpo(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return (t == d) ? b + c : c * 1.001f * (-FMath::Pow(2.0f, -10.0f * t / d) + 1.0f) + b;
+ }
+ static float InOutExpo(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (t == 0) return b;
+ if (t == d) return b + c;
+ t /= d * 0.5f;
+ if (t < 1.0f)
+ {
+ return c * 0.5f * FMath::Pow(2.0f, 10.0f * (t - 1.0f)) + b - c * 0.0005f;
+ }
+ else
+ {
+ return c * 0.5f * 1.0005f * (-FMath::Pow(2.0f, -10.0f * (t - 1.0f)) + 2.0f) + b;
+ }
+ }
+ static float InCirc(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d;
+ return -c * (FMath::Sqrt(1.0f - t*t) - 1.0f) + b;
+ }
+ static float OutCirc(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t = t / d - 1.0f;
+ return c * FMath::Sqrt(1.0f - t*t) + b;
+ }
+ static float InOutCirc(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d * 0.5f;
+ if (t < 1)
+ {
+ return -c * 0.5f * (FMath::Sqrt(1 - t * t) - 1) + b;
+ }
+ else
+ {
+ t -= 2.0f;
+ return c * 0.5f * (FMath::Sqrt(1.0f - t*t) + 1.0f) + b;
+ }
+ }
+ static float InElastic(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (t == 0) return b;
+ t /= d;
+ if (t == 1) return b + c;
+ float p = d*0.3f;
+ float s = p / 4;
+ float a = c;
+ t -= 1.0f;
+ return -(a*FMath::Pow(2.0f, 10.0f * t) * FMath::Sin((t*d - s)*(2.0f * PI) / p)) + b;
+ }
+ static float OutElastic(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (t == 0) return b;
+ t /= d;
+ if (t == 1) return b + c;
+ float p = d*0.3f;
+ float s = p / 4;
+ float a = c;
+ return (a*FMath::Pow(2.0f, -10.0f * t) * FMath::Sin((t*d - s)*(2.0f * PI) / p) + c + b);
+ }
+ static float InOutElastic(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (t == 0) return b;
+ t /= d * 0.5f;
+ if (t == 2) return b + c;
+ float p = d*0.3f;
+ float s = p / 4;
+ float a = c;
+ if (t < 1.0f)
+ {
+ t -= 1.0f;
+ return -0.5f*(a*FMath::Pow(2.0f, 10.0f * t) * FMath::Sin((t*d - s)*(2.0f * PI) / p)) + b;
+ }
+ else
+ {
+ t -= 1.0f;
+ return a * FMath::Pow(2.0f, -10.0f * t) * FMath::Sin((t*d - s)*(2.0f * PI) / p)*0.5f + c + b;
+ }
+ }
+ static float InBack(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ static float s = 1.70158f;
+ t /= d;
+ return c*t*t*((s + 1)*t - s) + b;
+ }
+ static float OutBack(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ static float s = 1.70158f;
+ t = t / d - 1;
+ return c*(t*t*((s + 1)*t + s) + 1) + b;
+ }
+ static float InOutBack(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (t < d * 0.5f) return InBack(c, 0, t * 2, d) * .5f + b;
+ else return OutBack(c, 0, t * 2 - d, d) * .5f + c * .5f + b;
+ }
+
+ static float OutBounce(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ t /= d;
+ if (t < (1.0f / 2.75f)) {
+ return c*(7.5625f*t*t) + b;
+ }
+ else if (t < (2.0f / 2.75f)) {
+ t -= (1.5f / 2.75f);
+ return c*(7.5625f*t*t + .75f) + b;
+ }
+ else if (t < (2.5f / 2.75f)) {
+ t -= (2.25f / 2.75f);
+ return c*(7.5625f*t*t + .9375f) + b;
+ }
+ else {
+ t -= (2.625f / 2.75f);
+ return c*(7.5625f*t*t + .984375f) + b;
+ }
+ }
+ static float InBounce(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ return c - OutBounce(c, 0, d - t, d) + b;
+ }
+ static float InOutBounce(float c, float b, float t, float d)
+ {
+ if (d < KINDA_SMALL_NUMBER)return c + b;
+ if (t < d * 0.5f) return InBounce(c, 0, t * 2, d) * .5f + b;
+ else return OutBounce(c, 0, t * 2 - d, d) * .5f + c * .5f + b;
+ }
+ /** Tween use CurveFloat, in range of 0-1. if curveFloat is null, fallback to Linear */
+ float CurveFloat(float c, float b, float t, float d);
+#pragma endregion
+};
\ No newline at end of file
diff --git a/Plugins/LTween/Source/LTween/Public/LTweenerSequence.h b/Plugins/LTween/Source/LTween/Public/LTweenerSequence.h
new file mode 100644
index 0000000..2866c24
--- /dev/null
+++ b/Plugins/LTween/Source/LTween/Public/LTweenerSequence.h
@@ -0,0 +1,71 @@
+// Copyright 2019-Present LexLiu. All Rights Reserved.
+
+#pragma once
+#include "LTweener.h"
+#include "LTweenerSequence.generated.h"
+
+UCLASS(BlueprintType)
+class LTWEEN_API ULTweenerSequence:public ULTweener
+{
+ GENERATED_BODY()
+private:
+ UPROPERTY(VisibleAnywhere, Category = LTween)TArray> tweenerList;
+ UPROPERTY(VisibleAnywhere, Category = LTween)TArray> finishedTweenerList;
+ float lastTweenStartTime = 0;
+public:
+ /**
+ * Adds the given tween to the end of the Sequence.
+ * Not support Tweener type: Delay/ DelayFrame/ Virtual.
+ * Has no effect if the Sequence has already started.
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ ULTweenerSequence* Append(UObject* WorldContextObject, ULTweener* tweener);
+ /**
+ * Adds the given interval to the end of the Sequence.
+ * Has no effect if the Sequence has already started.
+ * @param interval The interval duration
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ ULTweenerSequence* AppendInterval(UObject* WorldContextObject, float interval);
+ /**
+ * Inserts the given tween at the given time position in the Sequence, automatically adding an interval if needed.
+ * Not support Tweener type: Delay/ DelayFrame/ Virtual.
+ * Has no effect if the Sequence has already started.
+ * @param timePosition The time position where the tween will be placed
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ ULTweenerSequence* Insert(UObject* WorldContextObject, float timePosition, ULTweener* tweener);
+ /**
+ * Adds the given tween to the beginning of the Sequence, pushing forward the other nested content.
+ * Not support Tweener type: Delay/ DelayFrame/ Virtual.
+ * Has no effect if the Sequence has already started.
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ ULTweenerSequence* Prepend(UObject* WorldContextObject, ULTweener* tweener);
+ /**
+ * Adds the given interval to the beginning of the Sequence, pushing forward the other nested content.
+ * Has no effect if the Sequence has already started.
+ * @param interval The interval duration
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ ULTweenerSequence* PrependInterval(UObject* WorldContextObject, float interval);
+ /**
+ * Inserts the given tween at the same time position of the last tween added to the Sequence.
+ * Note that, in case of a Join after an interval, the insertion time will be the time where the interval starts, not where it finishes.
+ * Not support Tweener type: Delay/ DelayFrame/ Virtual.
+ * Has no effect if the Sequence has already started.
+ */
+ UFUNCTION(BlueprintCallable, meta = (WorldContext = "WorldContextObject"), Category = LTween)
+ ULTweenerSequence* Join(UObject* WorldContextObject, ULTweener* tweener);
+
+protected:
+ virtual void OnStartGetValue() override {};
+ virtual void TweenAndApplyValue(float currentTime) override;
+ virtual void SetValueForIncremental() override;
+ virtual void SetValueForYoyo() override;
+ virtual void SetValueForRestart() override;
+ virtual void SetOriginValueForRestart() override;
+
+ virtual void Restart()override;
+ virtual void Goto(float timePoint)override;
+};
\ No newline at end of file
diff --git a/Plugins/SUDS/Extras/PygmentsLexer/.vscode/settings.json b/Plugins/SUDS/Extras/PygmentsLexer/.vscode/settings.json
new file mode 100644
index 0000000..50b0517
--- /dev/null
+++ b/Plugins/SUDS/Extras/PygmentsLexer/.vscode/settings.json
@@ -0,0 +1,6 @@
+{
+ "cSpell.words": [
+ "speakerline",
+ "squarebrackets"
+ ]
+}
\ No newline at end of file
diff --git a/Plugins/SUDS/Extras/PygmentsLexer/setup.py b/Plugins/SUDS/Extras/PygmentsLexer/setup.py
new file mode 100644
index 0000000..c8b594c
--- /dev/null
+++ b/Plugins/SUDS/Extras/PygmentsLexer/setup.py
@@ -0,0 +1,12 @@
+from setuptools import setup, find_packages
+
+setup (
+ name='sudslexer',
+ packages=find_packages(),
+ version="0.4.0",
+ entry_points =
+ """
+ [pygments.lexers]
+ sudslexer = sudslexer.lexer:SudsLexer
+ """,
+)
\ No newline at end of file
diff --git a/Plugins/SUDS/Extras/PygmentsLexer/sudslexer/__init__.py b/Plugins/SUDS/Extras/PygmentsLexer/sudslexer/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/Plugins/SUDS/Extras/PygmentsLexer/sudslexer/lexer.py b/Plugins/SUDS/Extras/PygmentsLexer/sudslexer/lexer.py
new file mode 100644
index 0000000..66eec43
--- /dev/null
+++ b/Plugins/SUDS/Extras/PygmentsLexer/sudslexer/lexer.py
@@ -0,0 +1,71 @@
+from pygments.lexer import RegexLexer, bygroups
+from pygments.token import *
+
+class SudsLexer(RegexLexer):
+ name = 'SUDS'
+ aliases = ['suds']
+ filenames = ['*.sud']
+
+ tokens = {
+ 'root': [
+ (r'===\s*\n', Generic.Heading),
+ # Choices
+ (r'\s*\*\-?\s+[^\@\n]+[\@\n]', Generic.Subheading),
+ (r'\s*#.*\n', Comment),
+ # Speaker lines
+ (r'\s*\S+\:', Name.Class, 'speakerline'),
+ # Open brackets for special functions
+ (r'\[', Operator, 'squarebrackets'),
+
+ # Variables
+ (r'(\{)([\w\.]+)(\})', bygroups(Operator, Name.Variable, Operator)),
+ (r'(\|)(plural|gender)(\()(.*?)(\))', bygroups(Operator, Keyword, Operator, Keyword, Operator)),
+ (r'\b([tT]rue|[fF]alse|[mM]asculine|[fF]eminine|[nN]euter)\b', Name.Constant),
+ # Line IDs
+ (r'\@[0-9a-fA-F]+\@', Comment.Special),
+ # Embedded markup
+ (r'\<\w+\>', Name.Decorator),
+ (r'\<\/\>', Name.Decorator),
+ # Goto labels
+ (r'\s*:\S+\n', Name.Label),
+ # Comments
+ (r'\s*\#[\=\+\%]?.*\n', Comment.Special),
+ # Fallback for all other text
+ # Needs an optional \n on the end to finish lines correctly
+ (r'\s+[\n]?', Text),
+ (r'\S+?[\n]?', Text), # non-greedy so we don't consume all non-whitespace
+
+
+ ],
+ # While in a speaker line, we ignore everything else except variables & markup
+ 'speakerline' : [
+ # Variables
+ (r'(\{)([\w\.]+)(\})', bygroups(Operator, Name.Variable, Operator)),
+ (r'(\|)(plural|gender)(\()(.*?)(\))', bygroups(Operator, Keyword, Operator, Keyword, Operator)),
+ (r'[\@\n]', Text, '#pop'),
+ # Embedded markup
+ (r'\<\w+\>', Name.Decorator),
+ (r'\<\/\>', Name.Decorator),
+ (r'[^\@\n\<\{]+', Text),
+
+ ],
+ # While in a [] block, highlight operators etc (don't do it elsewhere)
+ 'squarebrackets' : [
+ # Close bracket finishes
+ (r'\]\s*[\n]?', Operator, '#pop'),
+ # Variables
+ (r'(\{)([\w\.]+)(\})', bygroups(Operator, Name.Variable, Operator)),
+ (r'\+\/\-\*\!\%', Operator),
+ (r'\"[^\"]*\"', String.Double),
+ (r'\`[^\`]*\`', String.Escape),
+ (r'\d+(\.\d+)?', Number),
+ (r'\b([tT]rue|[fF]alse|[mM]asculine|[fF]eminine|[nN]euter)\b', Name.Constant),
+ # Set, event commands so we can highlight variable/event differently
+ (r'\s*(set|event)(\s+)([^\]\s]+)', bygroups(Keyword, Text, Name.Variable)),
+ (r'\s*(if|else|elseif|endif|event|return|goto|gosub|go to|go sub|random|endrandom)\b', Keyword),
+ (r'\b(and|or|&&|\|\||not)\b', Operator),
+ (r'[,]', Punctuation),
+ (r'\s+', Text), # whitespace OK
+
+ ]
+ }
\ No newline at end of file
diff --git a/Plugins/SUDS/Source/SUDS/Private/SUDSValue.cpp b/Plugins/SUDS/Source/SUDS/Private/SUDSValue.cpp
index 6dac784..0782e31 100644
--- a/Plugins/SUDS/Source/SUDS/Private/SUDSValue.cpp
+++ b/Plugins/SUDS/Source/SUDS/Private/SUDSValue.cpp
@@ -2,6 +2,9 @@
// Released under the MIT license https://opensource.org/license/MIT/
#include "SUDSValue.h"
+#include "UObject/Class.h"
+#include "Internationalization/Text.h"
+
FArchive& operator<<(FArchive& Ar, FSUDSValue& Value)
{
// Custom serialisation since we can't auto-serialise union, TOptional
@@ -62,7 +65,11 @@ FString FSUDSValue::ToString() const
case ESUDSValueType::Boolean:
return GetBooleanValue() ? "True" : "False";
case ESUDSValueType::Gender:
- return StaticEnum()->GetNameStringByValue((int64)GetGenderValue());
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ return LexToString(GetGenderValue());
+#else
+ return *StaticEnum()->GetNameStringByValue((int64)GetGenderValue());
+#endif
case ESUDSValueType::Name:
return GetNameValue().ToString();
case ESUDSValueType::Variable:
diff --git a/Plugins/SUDS/Source/SUDSEditor/Private/SUDSEditorToolkit.cpp b/Plugins/SUDS/Source/SUDSEditor/Private/SUDSEditorToolkit.cpp
index 70165f7..8b61ff5 100644
--- a/Plugins/SUDS/Source/SUDSEditor/Private/SUDSEditorToolkit.cpp
+++ b/Plugins/SUDS/Source/SUDSEditor/Private/SUDSEditorToolkit.cpp
@@ -706,7 +706,11 @@ void FSUDSEditorToolkit::OnDialogueChoice(USUDSDialogue* D, int ChoiceIndex, int
void FSUDSEditorToolkit::OnDialogueEvent(USUDSDialogue* D, FName EventName, const TArray& Args, int LineNo)
{
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ TStringBuilder<256> B;
+#else
FStringBuilderBase B;
+#endif
if (Args.Num() > 0)
{
for (auto& Arg : Args)
@@ -1372,6 +1376,24 @@ TSharedRef SSUDSEditorVariableItem::GetGenderMenu()
{
FMenuBuilder MenuBuilder(true, NULL);
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ // StaticEnum() doesn't exist anymore so we have to do this manually
+ const FUIAction Action0(FExecuteAction::CreateSP(this, &SSUDSEditorVariableItem::OnGenderSelected, ETextGender::Feminine));
+ MenuBuilder.AddMenuEntry(FText::FromString(LexToString(ETextGender::Feminine)),
+ FText(),
+ FSlateIcon(),
+ Action0);
+ const FUIAction Action1(FExecuteAction::CreateSP(this, &SSUDSEditorVariableItem::OnGenderSelected, ETextGender::Masculine));
+ MenuBuilder.AddMenuEntry(FText::FromString(LexToString(ETextGender::Masculine)),
+ FText(),
+ FSlateIcon(),
+ Action1);
+ const FUIAction Action2(FExecuteAction::CreateSP(this, &SSUDSEditorVariableItem::OnGenderSelected, ETextGender::Neuter));
+ MenuBuilder.AddMenuEntry(FText::FromString(LexToString(ETextGender::Neuter)),
+ FText(),
+ FSlateIcon(),
+ Action2);
+#else
// NumEnums() - 1 because the last value is the autogen _MAX value
for (int i = 0; i < StaticEnum()->NumEnums() - 1; ++i)
{
@@ -1383,6 +1405,7 @@ TSharedRef SSUDSEditorVariableItem::GetGenderMenu()
Action);
}
+#endif
return MenuBuilder.MakeWidget();
diff --git a/Plugins/SUDS/Source/SUDSEditor/Private/SUDSScriptImporter.cpp b/Plugins/SUDS/Source/SUDSEditor/Private/SUDSScriptImporter.cpp
index 56d8edf..cf1d912 100644
--- a/Plugins/SUDS/Source/SUDSEditor/Private/SUDSScriptImporter.cpp
+++ b/Plugins/SUDS/Source/SUDSEditor/Private/SUDSScriptImporter.cpp
@@ -1772,7 +1772,11 @@ FString FSUDSScriptImporter::GetCurrentTreePath(const FSUDSScriptImporter::Parse
// Do NOT fallthrough to here
// Fallthrough to here instead (/)
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ TStringBuilder<256> B;
+#else
FStringBuilderBase B;
+#endif
for (auto Indent : Tree.IndentLevelStack)
{
B.Appendf(TEXT("%s%s"), *Indent.PathEntry, *TreePathSeparator);
@@ -1784,7 +1788,11 @@ FString FSUDSScriptImporter::GetCurrentTreeConditionalPath(const FSUDSScriptImpo
{
// Like GetCurrentTreePath, but for conditional blocks
// Cannot fall through to blocks that aren't on the same conditional path
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ TStringBuilder<256> B;
+#else
FStringBuilderBase B;
+#endif
int BlockIdx = Tree.CurrentConditionalBlockIdx;
B.Append(TreePathSeparator);
// work backwards, hence prepend
@@ -1803,7 +1811,11 @@ FString FSUDSScriptImporter::GetCurrentTreeConditionalPath(const FSUDSScriptImpo
FString FSUDSScriptImporter::GetTreeConditionalPath(const FSUDSScriptImporter::ParsedTree& Tree, int NodeIndex)
{
// Like GetCurrentTreeConditionalPath, but we're not in the block context. Follow the nodes back up
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ TStringBuilder<256> B;
+#else
FStringBuilderBase B;
+#endif
B.Append(TreePathSeparator);
while (Tree.Nodes.IsValidIndex(NodeIndex))
@@ -2543,7 +2555,11 @@ void FSUDSScriptImporter::PopulateAssetFromTree(USUDSScript* Asset,
{
case ESUDSParsedNodeType::Text:
{
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ StringTable->GetMutableStringTable()->SetSourceString(InNode.TextID, InNode.Text, "");
+#else
StringTable->GetMutableStringTable()->SetSourceString(InNode.TextID, InNode.Text);
+#endif
// Always include speaker metadata
StringTable->GetMutableStringTable()->SetMetaData(InNode.TextID, FName("Speaker"), InNode.Identifier);
// Other metadata
@@ -2579,7 +2595,11 @@ void FSUDSScriptImporter::PopulateAssetFromTree(USUDSScript* Asset,
FSUDSExpression Expr = InNode.Expression;
if (Expr.IsTextLiteral())
{
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ StringTable->GetMutableStringTable()->SetSourceString(InNode.TextID, Expr.GetTextLiteralValue().ToString(), "");
+#else
StringTable->GetMutableStringTable()->SetSourceString(InNode.TextID, Expr.GetTextLiteralValue().ToString());
+#endif
Expr.SetTextLiteralValue(FText::FromStringTable (StringTable->GetStringTableId(), InNode.TextID));
}
SetNode->Init(InNode.Identifier, Expr, InNode.SourceLineNo);
@@ -2707,7 +2727,11 @@ void FSUDSScriptImporter::PopulateAssetFromTree(USUDSScript* Asset,
if (!InEdge.TextID.IsEmpty() && !InEdge.Text.IsEmpty())
{
+#if ENGINE_MAJOR_VERSION ==5 && ENGINE_MINOR_VERSION >= 8
+ StringTable->GetMutableStringTable()->SetSourceString(InEdge.TextID, InEdge.Text, "");
+#else
StringTable->GetMutableStringTable()->SetSourceString(InEdge.TextID, InEdge.Text);
+#endif
NewEdge.SetText(FText::FromStringTable(StringTable->GetStringTableId(), InEdge.TextID));
// Always include speaker metadata, always the player in a choice
// Identify that it's a choice so translators know that there may be more limited space
diff --git a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesBPL.cpp b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesBPL.cpp
index b9d043c..1756da8 100644
--- a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesBPL.cpp
+++ b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesBPL.cpp
@@ -3,7 +3,7 @@
#include "StevesBPL.h"
-
+#include "Misc/ConfigCacheIni.h"
#include "StevesUiHelpers.h"
#include "StevesUI/StevesUI.h"
#include "ContentStreaming.h"
diff --git a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesEasings.cpp b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesEasings.cpp
index 9ff0206..36253ae 100644
--- a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesEasings.cpp
+++ b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesEasings.cpp
@@ -8,7 +8,7 @@ float UStevesEasings::EaseAlpha(float InAlpha, EStevesEaseFunction Func)
constexpr float BackC2 = BackC1 * 1.525f;
constexpr float BackC3 = BackC1 + 1.f;
constexpr float ElasticC4 = UE_TWO_PI / 3.f;
- constexpr float ElasticC5 = UE_TWO_PI / 4.5;
+ constexpr float ElasticC5 = UE_TWO_PI / 4.5f;
switch(Func)
{
diff --git a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesGameSubsystem.cpp b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesGameSubsystem.cpp
index cb92874..e90a02c 100644
--- a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesGameSubsystem.cpp
+++ b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Private/StevesGameSubsystem.cpp
@@ -110,7 +110,7 @@ void UStevesGameSubsystem::NotifyEnhancedInputMappingsChanged()
OnEnhancedInputMappingsChanged.Broadcast();
};
FTimerHandle TempHandle;
- GetWorld()->GetTimerManager().SetTimer(TempHandle, FTimerDelegate::CreateLambda(DelayedFunc), 0.05, false);
+ GetWorld()->GetTimerManager().SetTimer(TempHandle, FTimerDelegate::CreateLambda(DelayedFunc), 0.05f, false);
}
TSoftObjectPtr UStevesGameSubsystem::FindEnhancedInputAction(const FString& Name)
diff --git a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesBalancedRandomStream.h b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesBalancedRandomStream.h
index de57624..ccc479e 100644
--- a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesBalancedRandomStream.h
+++ b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesBalancedRandomStream.h
@@ -262,13 +262,13 @@ public:
*/
uint32 GetCurrentSeed() const
{
- return InitialSeed;
+ return Seed;
}
FString ToString() const
{
- return FString::Printf(TEXT("FStevesBalancedRandomStream(InitialSeed=%i, Seed=%u)"), InitialSeed, InitialSeed);
+ return FString::Printf(TEXT("FStevesBalancedRandomStream(InitialSeed=%u, Seed=%u)"), InitialSeed, Seed);
}
@@ -407,13 +407,13 @@ public:
*/
FORCEINLINE uint32 GetCurrentSeed() const
{
- return InitialSeed;
+ return Seed;
}
FString ToString() const
{
- return FString::Printf(TEXT("FStevesBalancedRandomStream1D(InitialSeed=%i, Seed=%u)"), InitialSeed, InitialSeed);
+ return FString::Printf(TEXT("FStevesBalancedRandomStream1D(InitialSeed=%u, Seed=%u)"), InitialSeed, Seed);
}
};
@@ -650,13 +650,13 @@ public:
*/
uint32 GetCurrentSeed() const
{
- return InitialSeed;
+ return Base2Seed;
}
FString ToString() const
{
- return FString::Printf(TEXT("FStevesBalancedRandomStream2D(InitialSeed=%i, Seed=%u)"), InitialSeed, InitialSeed);
+ return FString::Printf(TEXT("FStevesBalancedRandomStream2D(InitialSeed=%u, Seed=%u)"), InitialSeed, Base2Seed);
}
};
@@ -775,7 +775,7 @@ public:
uint32 GetInitialSeed() const
{
- return InitialSeed;
+ return Base2Seed;
}
/**
@@ -922,7 +922,7 @@ public:
FString ToString() const
{
- return FString::Printf(TEXT("FStevesBalancedRandomStream(InitialSeed=%i, Seed=%u)"), InitialSeed, InitialSeed);
+ return FString::Printf(TEXT("FStevesBalancedRandomStream(InitialSeed=%u, Seed=%u)"), InitialSeed, Base2Seed);
}
diff --git a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesGameSubsystem.h b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesGameSubsystem.h
index a294e31..5ba8245 100644
--- a/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesGameSubsystem.h
+++ b/Plugins/StevesUEHelpers/Source/StevesUEHelpers/Public/StevesGameSubsystem.h
@@ -103,7 +103,7 @@ protected:
const EInputMode DefaultButtonInputMode = EInputMode::Keyboard;
const EInputMode DefaultAxisInputMode = EInputMode::Mouse;
const float MouseMoveThreshold = 1;
- const float GamepadAxisThreshold = 0.2;
+ const float GamepadAxisThreshold = 0.2f;
bool ShouldProcessInputEvents() const;
public:
diff --git a/Plugins/StevesUEHelpers/StevesUEHelpers.uplugin b/Plugins/StevesUEHelpers/StevesUEHelpers.uplugin
index 7eed4e0..8bbc790 100644
--- a/Plugins/StevesUEHelpers/StevesUEHelpers.uplugin
+++ b/Plugins/StevesUEHelpers/StevesUEHelpers.uplugin
@@ -1,40 +1,38 @@
{
- "FileVersion": 3,
- "Version": 1,
- "VersionName": "1.1.1.0",
- "EngineVersion": "",
- "FriendlyName": "Steve's UE Helpers",
- "Description": "A set of common helper classes for UE projects by Steve Streeting",
- "Category": "Code Utilities",
- "CreatedBy": "Steve Streeting",
- "CreatedByURL": "https://www.stevestreeting.com",
- "DocsURL": "https://github.com/sinbad/StevesUEHelpers/blob/master/ReadMe.md",
- "MarketplaceURL": "com.epicgames.launcher://ue/Fab/product/6a48c58c-1771-42f6-b46f-2b09e31b1699",
- "SupportURL": "https://github.com/sinbad/StevesUEHelpers",
- "EnabledByDefault": true,
- "CanContainContent": false,
- "IsBetaVersion": false,
- "Installed": false,
- "Modules": [
- {
- "Name": "StevesUEHelpers",
- "Type": "Runtime",
- "LoadingPhase": "PreDefault",
- "PlatformAllowList": [
- "Win64",
- "Linux",
- "Mac"
- ]
- },
- {
- "Name": "StevesUEHelpersEd",
- "Type": "Editor",
- "LoadingPhase": "PostDefault",
- "PlatformAllowList": [
- "Win64",
- "Linux",
- "Mac"
- ]
- }
- ]
-}
+ "FileVersion": 3,
+ "Version": 1,
+ "VersionName": "1.2.1.0",
+ "FriendlyName": "Steve's UE Helpers",
+ "Description": "A set of common helper classes for UE projects by Steve Streeting",
+ "Category": "Code Utilities",
+ "CreatedBy": "Steve Streeting",
+ "CreatedByURL": "https://www.stevestreeting.com",
+ "DocsURL": "https://github.com/sinbad/StevesUEHelpers/blob/master/ReadMe.md",
+ "MarketplaceURL": "com.epicgames.launcher://ue/Fab/product/6a48c58c-1771-42f6-b46f-2b09e31b1699",
+ "SupportURL": "https://github.com/sinbad/StevesUEHelpers",
+ "EngineVersion": "5.8.0",
+ "CanContainContent": false,
+ "Installed": true,
+ "Modules": [
+ {
+ "Name": "StevesUEHelpers",
+ "Type": "Runtime",
+ "LoadingPhase": "PreDefault",
+ "PlatformAllowList": [
+ "Win64",
+ "Linux",
+ "Mac"
+ ]
+ },
+ {
+ "Name": "StevesUEHelpersEd",
+ "Type": "Editor",
+ "LoadingPhase": "PostDefault",
+ "PlatformAllowList": [
+ "Win64",
+ "Linux",
+ "Mac"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Source/Faye.Target.cs b/Source/Faye.Target.cs
index 19a473e..d25090b 100644
--- a/Source/Faye.Target.cs
+++ b/Source/Faye.Target.cs
@@ -8,8 +8,8 @@ public class FayeTarget : TargetRules
public FayeTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
- DefaultBuildSettings = BuildSettingsVersion.V6;
- IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_7;
+ DefaultBuildSettings = BuildSettingsVersion.V7;
+ IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_8;
ExtraModuleNames.Add("Faye");
}
}
diff --git a/Source/FayeEditor.Target.cs b/Source/FayeEditor.Target.cs
index ef50599..91cf6c5 100644
--- a/Source/FayeEditor.Target.cs
+++ b/Source/FayeEditor.Target.cs
@@ -8,8 +8,8 @@ public class FayeEditorTarget : TargetRules
public FayeEditorTarget( TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
- DefaultBuildSettings = BuildSettingsVersion.V6;
- IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_7;
+ DefaultBuildSettings = BuildSettingsVersion.V7;
+ IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_8;
ExtraModuleNames.Add("Faye");
}
}