Updated to UE5.2 (property getters) (TArray)

Source/BUITween/Private/BUITween.cpp

@@ -61,18 +61,15 @@ void UBUITween::Update( float DeltaTime )
 		if ( Inst.IsComplete() )
 		{
 			FBUITweenInstance CompleteInst = Inst;
-			ActiveInstances.RemoveAt( i );
+			ActiveInstances.RemoveAtSwap( i );
 
 			// We do this here outside of the instance update and after removing from active instances because we
 			// don't know if the callback in the cleanup is going to trigger adding more events
 			CompleteInst.DoCompleteCleanup();
 		}
 	}
 
-	for ( int32 i = 0; i < InstancesToAdd.Num(); ++i )
-	{
-		ActiveInstances.Add( InstancesToAdd[ i ] );
-	}
+	ActiveInstances.Append(MoveTemp(InstancesToAdd));
 	InstancesToAdd.Empty();
 }
 

Source/BUITween/Private/BUITweenInstance.cpp

@@ -25,26 +25,26 @@ void FBUITweenInstance::Begin()
 	}
 
 	// Set all the props to the existng state
-	TranslationProp.OnBegin( pWidget->RenderTransform.Translation );
-	ScaleProp.OnBegin( pWidget->RenderTransform.Scale );
-	RotationProp.OnBegin( pWidget->RenderTransform.Angle );
+	TranslationProp.OnBegin( pWidget->GetRenderTransform().Translation );
+	ScaleProp.OnBegin( pWidget->GetRenderTransform().Scale );
+	RotationProp.OnBegin( pWidget->GetRenderTransform().Angle );
 	OpacityProp.OnBegin( pWidget->GetRenderOpacity() );
 
 	{
 		UUserWidget* UW = Cast<UUserWidget>( pWidget );
 		if ( UW )
 		{
-			ColorProp.OnBegin( UW->ColorAndOpacity );
+			ColorProp.OnBegin( UW->GetColorAndOpacity() );
 		}
 		UImage* UI = Cast<UImage>( pWidget );
 		if ( UI )
 		{
-			ColorProp.OnBegin( UI->ColorAndOpacity );
+			ColorProp.OnBegin( UI->GetColorAndOpacity() );
 		}
 		UBorder* Border = Cast<UBorder>( pWidget );
 		if ( Border )
 		{
-			ColorProp.OnBegin( Border->ContentColorAndOpacity );
+			ColorProp.OnBegin( Border->GetContentColorAndOpacity() );
 		}
 	}
 
@@ -61,32 +61,32 @@ void FBUITweenInstance::Begin()
 	if ( OverlaySlot )
 	{
 		PaddingProp.OnBegin( FVector4(
-			OverlaySlot->Padding.Left,
-			OverlaySlot->Padding.Top,
-			OverlaySlot->Padding.Bottom,
-			OverlaySlot->Padding.Right ) );
+			OverlaySlot->GetPadding().Left,
+			OverlaySlot->GetPadding().Top,
+			OverlaySlot->GetPadding().Bottom,
+			OverlaySlot->GetPadding().Right ) );
 	}
 	else if ( HorizontalBoxSlot )
 	{
 		PaddingProp.OnBegin( FVector4(
-			HorizontalBoxSlot->Padding.Left,
-			HorizontalBoxSlot->Padding.Top,
-			HorizontalBoxSlot->Padding.Bottom,
-			HorizontalBoxSlot->Padding.Right ) );
+			HorizontalBoxSlot->GetPadding().Left,
+			HorizontalBoxSlot->GetPadding().Top,
+			HorizontalBoxSlot->GetPadding().Bottom,
+			HorizontalBoxSlot->GetPadding().Right ) );
 	}
 	else if ( VerticalBoxSlot )
 	{
 		PaddingProp.OnBegin( FVector4(
-			VerticalBoxSlot->Padding.Left,
-			VerticalBoxSlot->Padding.Top,
-			VerticalBoxSlot->Padding.Bottom,
-			VerticalBoxSlot->Padding.Right ) );
+			VerticalBoxSlot->GetPadding().Left,
+			VerticalBoxSlot->GetPadding().Top,
+			VerticalBoxSlot->GetPadding().Bottom,
+			VerticalBoxSlot->GetPadding().Right ) );
 	}
 
 	USizeBox* SizeBox = Cast<USizeBox>( pWidget );
 	if ( SizeBox )
 	{
-		MaxDesiredHeightProp.OnBegin( SizeBox->MaxDesiredHeight );
+		MaxDesiredHeightProp.OnBegin( SizeBox->GetMaxDesiredHeight() );
 	}
 
 	// Apply the starting conditions, even if we delay
@@ -115,6 +115,7 @@ void FBUITweenInstance::Update( float DeltaTime )
 	if ( !bHasPlayedStartEvent )
 	{
 		OnStartedDelegate.ExecuteIfBound( pWidget.Get() );
+		OnStartedBPDelegate.ExecuteIfBound( pWidget.Get() );
 		bHasPlayedStartEvent = true;
 	}
 
@@ -173,7 +174,7 @@ void FBUITweenInstance::Apply( float EasedAlpha )
 	}
 
 	bool bChangedRenderTransform = false;
-	FWidgetTransform CurrentTransform = Target->RenderTransform;
+	FWidgetTransform CurrentTransform = Target->GetRenderTransform();
 
 	if ( TranslationProp.IsSet() )
 	{

Source/BUITween/Private/BUITweenModule.cpp

@@ -28,4 +28,3 @@ void FBUITweenModule::Tick( float DeltaTime )
 #undef LOCTEXT_NAMESPACE
 
 IMPLEMENT_MODULE(FBUITweenModule, BUITween)
-

Source/BUITween/Public/BUIEasing.h

@@ -40,7 +40,7 @@ enum class EBUIEasingType
 struct FBUIEasing
 {
 public:
-	#define TWO_PI          (6.28318530717f)
+	#define BUI_TWO_PI          (6.28318530717f)
 
 	static float Ease( EBUIEasingType Type, float time, float duration = 1.0f, float overshootOrAmplitude = 0.1f, float period = 1.0f )
 	{
@@ -245,9 +245,9 @@ struct FBUIEasing
 			overshootOrAmplitude = 1;
 			s0 = period / 4;
 		}
-		else s0 = period / TWO_PI * ( float ) FMath::Asin( 1 / overshootOrAmplitude );
+		else s0 = period / BUI_TWO_PI * ( float ) FMath::Asin( 1 / overshootOrAmplitude );
 		time -= 1;
-		return -( overshootOrAmplitude * ( float ) FMath::Pow( 2, 10 * time ) * ( float ) FMath::Sin( ( time * duration - s0 ) * TWO_PI / period ) );
+		return -( overshootOrAmplitude * ( float ) FMath::Pow( 2, 10 * time ) * ( float ) FMath::Sin( ( time * duration - s0 ) * BUI_TWO_PI / period ) );
 	}
 
 	static float OutElastic( float time, float duration = 1.0f, float overshootOrAmplitude = 0.1f, float period = 1.0f )
@@ -261,8 +261,8 @@ struct FBUIEasing
 			overshootOrAmplitude = 1;
 			s1 = period / 4;
 		}
-		else s1 = period / TWO_PI * ( float ) FMath::Asin( 1 / overshootOrAmplitude );
-		return ( overshootOrAmplitude * ( float ) FMath::Pow( 2, -10 * time ) * ( float ) FMath::Sin( ( time * duration - s1 ) * TWO_PI / period ) + 1 );
+		else s1 = period / BUI_TWO_PI * ( float ) FMath::Asin( 1 / overshootOrAmplitude );
+		return ( overshootOrAmplitude * ( float ) FMath::Pow( 2, -10 * time ) * ( float ) FMath::Sin( ( time * duration - s1 ) * BUI_TWO_PI / period ) + 1 );
 	}
 
 	static float InOutElastic( float time, float duration = 1.0f, float overshootOrAmplitude = 0.1f, float period = 1.0f )
@@ -276,11 +276,11 @@ struct FBUIEasing
 			overshootOrAmplitude = 1;
 			s = period / 4;
 		}
-		else s = period / TWO_PI * ( float ) FMath::Asin( 1 / overshootOrAmplitude );
+		else s = period / BUI_TWO_PI * ( float ) FMath::Asin( 1 / overshootOrAmplitude );
 		time -= 1;
 		if ( time < 1 )
-			return -0.5f * ( overshootOrAmplitude * ( float ) FMath::Pow( 2, 10 * time ) * ( float ) FMath::Sin( ( time * duration - s ) * TWO_PI / period ) );
-		return overshootOrAmplitude * ( float ) FMath::Pow( 2, -10 * time ) * ( float ) FMath::Sin( ( time * duration - s ) * TWO_PI / period ) * 0.5f + 1;
+			return -0.5f * ( overshootOrAmplitude * ( float ) FMath::Pow( 2, 10 * time ) * ( float ) FMath::Sin( ( time * duration - s ) * BUI_TWO_PI / period ) );
+		return overshootOrAmplitude * ( float ) FMath::Pow( 2, -10 * time ) * ( float ) FMath::Sin( ( time * duration - s ) * BUI_TWO_PI / period ) * 0.5f + 1;
 	}
 
 	static float InBack( float time, float duration = 1.0f, float overshootOrAmplitude = 0.1f, float period = 1.0f )
@@ -307,4 +307,4 @@ struct FBUIEasing
 
 };
 
-#undef TWO_PI
+#undef BUI_TWO_PI

Source/BUITween/Public/BUITween.h

@@ -34,3 +34,190 @@ class BUITWEEN_API UBUITween : public UObject
 	// We delay adding until the end of an update so we don't add to ActiveInstances within our update loop
 	static TArray< FBUITweenInstance > InstancesToAdd;
 };
+
+
+
+UCLASS(BlueprintType)
+class BUITWEEN_API UBUIParamChain : public UObject
+{
+	GENERATED_BODY()
+
+public:
+
+	FBUITweenInstance* TweenInstance;
+};
+
+UCLASS()
+class BUITWEEN_API UBUITweenBlueprintFunctionLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+
+public:
+
+	UFUNCTION(BlueprintCallable, Category = UITween)
+	static void RunAnimation(UBUIParamChain* Params)
+	{
+		Params->TweenInstance->Begin();
+		Params->ConditionalBeginDestroy();
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* CreateAnimationParams(UWidget* InWidget, const float InDuration = 1.0f, const float InDelay = 0.0f, const bool bIsAdditive = false)
+	{
+		FBUITweenInstance& Tween = UBUITween::Create(InWidget, InDuration, InDelay, bIsAdditive);
+		UBUIParamChain* Params = NewObject<UBUIParamChain>(GetTransientPackage(), TEXT(""), RF_MarkAsRootSet);
+		Params->TweenInstance = &Tween;
+		return Params;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToTranslation(UBUIParamChain* Previous, const FVector2D& InTarget)
+	{
+		Previous->TweenInstance->ToTranslation(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromTranslation(UBUIParamChain* Previous, const FVector2D& InStart)
+	{
+		Previous->TweenInstance->FromTranslation(InStart);
+		return Previous;
+	}
+
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToScale(UBUIParamChain* Previous, const FVector2D& InTarget)
+	{
+		Previous->TweenInstance->ToScale(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromScale(UBUIParamChain* Previous, const FVector2D& InStart)
+	{
+		Previous->TweenInstance->FromScale(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToOpacity(UBUIParamChain* Previous, const float InTarget)
+	{
+		Previous->TweenInstance->ToOpacity(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromOpacity(UBUIParamChain* Previous, const float InStart)
+	{
+		Previous->TweenInstance->FromOpacity(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToColor(UBUIParamChain* Previous, const FLinearColor& InTarget)
+	{
+		Previous->TweenInstance->ToColor(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromColor(UBUIParamChain* Previous, const FLinearColor& InStart)
+	{
+		Previous->TweenInstance->FromColor(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToRotation(UBUIParamChain* Previous, const float InTarget)
+	{
+		Previous->TweenInstance->ToRotation(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromRotation(UBUIParamChain* Previous, const float InStart)
+	{
+		Previous->TweenInstance->FromRotation(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToMaxDesiredHeight(UBUIParamChain* Previous, const float InTarget)
+	{
+		Previous->TweenInstance->ToMaxDesiredHeight(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromMaxDesiredHeight(UBUIParamChain* Previous, const float InStart)
+	{
+		Previous->TweenInstance->FromMaxDesiredHeight(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToCanvasPosition(UBUIParamChain* Previous, const FVector2D& InTarget)
+	{
+		Previous->TweenInstance->ToCanvasPosition(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromCanvasPosition(UBUIParamChain* Previous, const FVector2D& InStart)
+	{
+		Previous->TweenInstance->FromCanvasPosition(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToPadding(UBUIParamChain* Previous, const FMargin& InTarget)
+	{
+		Previous->TweenInstance->ToPadding(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromPadding(UBUIParamChain* Previous, const FMargin& InStart)
+	{
+		Previous->TweenInstance->FromPadding(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToVisibility(UBUIParamChain* Previous, const ESlateVisibility InTarget)
+	{
+		Previous->TweenInstance->ToVisibility(InTarget);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* FromVisibility(UBUIParamChain* Previous, const ESlateVisibility InStart)
+	{
+		Previous->TweenInstance->FromVisibility(InStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* OnStart(UBUIParamChain* Previous, const FBUITweenBPSignature& InOnStart)
+	{
+		Previous->TweenInstance->OnStart(InOnStart);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* OnComplete(UBUIParamChain* Previous, const FBUITweenBPSignature& InOnComplete)
+	{
+		Previous->TweenInstance->OnComplete(InOnComplete);
+		return Previous;
+	}
+
+	UFUNCTION(BlueprintPure, Category = UITween)
+	static UBUIParamChain* ToReset(UBUIParamChain* Previous)
+	{
+		Previous->TweenInstance->ToReset();
+		return Previous;
+	}
+
+private:
+
+};