AlphaBlend.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "AlphaBlend.generated.h"
 
class UCurveFloat;
 
UENUM(BlueprintType)
enum class EAlphaBlendOption : uint8
{
    Linear = 0 UMETA(Grouping = Linear, DisplayName = "Linear", ToolTip = "Linear interpolation"),
    Cubic UMETA(Grouping = Cubic, DisplayName = "Cubic In", ToolTip = "Cubic-in interpolation"),
    HermiteCubic UMETA(Grouping = Cubic, DisplayName = "Hermite-Cubic InOut", ToolTip = "Hermite-Cubic"),
    Sinusoidal UMETA(Grouping = Sinusoidal, DisplayName = "Sinusoidal", ToolTip = "Sinusoidal interpolation"),
    QuadraticInOut UMETA(Grouping = Quadratic, DisplayName = "Quadratic InOut", ToolTip = "Quadratic in-out interpolation"),
    CubicInOut UMETA(Grouping = Cubic, DisplayName = "Cubic InOut", ToolTip = "Cubic in-out interpolation"),
    QuarticInOut UMETA(Grouping = Quartic, DisplayName = "Quartic InOut", ToolTip = "Quartic in-out interpolation"),
    QuinticInOut UMETA(Grouping = Quintic, DisplayName = "Quintic InOut", ToolTip = "Quintic in-out interpolation"),
    CircularIn UMETA(Grouping = Circular, DisplayName = "Circular In", ToolTip = "Circular-in interpolation"),
    CircularOut UMETA(Grouping = Circular, DisplayName = "Circular Out", ToolTip = "Circular-out interpolation"),
    CircularInOut UMETA(Grouping = Circular, DisplayName = "Circular InOut", ToolTip = "Circular in-out interpolation"),
    ExpIn UMETA(Grouping = Exponential, DisplayName = "Exponential In", ToolTip = "Exponential-in interpolation"),
    ExpOut UMETA(Grouping = Exponential, DisplayName = "Exponential Out", ToolTip = "Exponential-Out interpolation"),
    ExpInOut UMETA(Grouping = Exponential, DisplayName = "Exponential InOut", ToolTip = "Exponential in-out interpolation"),
    Custom UMETA(Grouping = Custom, DisplayName = "Custom", ToolTip = "Custom interpolation, will use custom curve inside an FAlphaBlend or linear if none has been set"),
};
 
namespace UE::Anim
{
static constexpr EAlphaBlendOption DefaultBlendOption = EAlphaBlendOption::HermiteCubic;
}
 
USTRUCT(BlueprintType)
struct FAlphaBlendArgs
{
    GENERATED_BODY()
 
    ENGINE_API FAlphaBlendArgs();
    ENGINE_API FAlphaBlendArgs(float InBlendTime);
    ENGINE_API FAlphaBlendArgs(const struct FAlphaBlend& InAlphaBlend);
 
#if WITH_EDITORONLY_DATA
    bool Serialize(FArchive& Ar);
    bool Serialize(FStructuredArchive::FSlot Slot);
#endif // WITH_EDITORONLY_DATA 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blend", meta=(DisplayAfter="BlendOption"))
    TObjectPtr<UCurveFloat> CustomCurve;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blend")
    float BlendTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blend")
    EAlphaBlendOption BlendOption;
};
 
USTRUCT(BlueprintType)
struct FAlphaBlend
{
    GENERATED_BODY()
private:
    UPROPERTY(EditAnywhere, Category = "Blend", meta=(DisplayAfter="BlendOption"))
    TObjectPtr<UCurveFloat> CustomCurve;
 
public:
    /* Constructor */
    ENGINE_API FAlphaBlend(float NewBlendTime = 0.2f);
 
    /* Constructor */
    ENGINE_API FAlphaBlend(const FAlphaBlend& Other, float NewBlendTime);
 
    bool Serialize(FArchive& Ar);
    bool Serialize(FStructuredArchive::FSlot Slot);
 
    /* Constructor */
    ENGINE_API explicit FAlphaBlend(const FAlphaBlendArgs& InArgs);
 
    ENGINE_API void SetBlendOption(EAlphaBlendOption InBlendOption);
    ENGINE_API void SetCustomCurve(UCurveFloat* InCustomCurve);
    ENGINE_API void SetBlendTime(float InBlendTime);
 
    ENGINE_API void SetValueRange(float Begin, float Desired);
 
    ENGINE_API void SetDesiredValue(float InDesired);
 
    ENGINE_API void SetAlpha(float InAlpha);
 
    ENGINE_API float Update(float InDeltaTime);
 
    ENGINE_API bool IsComplete() const;
 
    float GetAlpha() const { return AlphaLerp; }
 
    float GetBlendedValue() const { return BlendedValue; }
 
    float GetBlendTime() const { return BlendTime; }
    float GetBlendTimeRemaining() const { return BlendTimeRemaining; }
    EAlphaBlendOption GetBlendOption() const { return BlendOption; }
    UCurveFloat* GetCustomCurve() const { return CustomCurve; }
 
    float GetBeginValue() const { return BeginValue; }
    
    float GetDesiredValue() const { return DesiredValue; }
 
    static ENGINE_API float AlphaToBlendOption(float InAlpha, EAlphaBlendOption InBlendOption, UCurveFloat* InCustomCurve = nullptr);
 
private:
    UPROPERTY(EditAnywhere, Category = "Blend")
    float   BlendTime;
 
    float   AlphaLerp;
 
    float   AlphaBlend;
 
    float   BlendTimeRemaining;
 
    float BlendedValue;
 
    float BeginValue;
 
    float DesiredValue;
 
public:
    ENGINE_API void Reset();
 
    ENGINE_API void ResetAlpha();
 
private:
    /* Reset Blend Time, this modifies BlendTimeRemaining and possibly Weight when BlendTimeRemaining <= 0.f */
    ENGINE_API void ResetBlendTime();
 
    ENGINE_API float AlphaToBlendOption();
 
    UPROPERTY(EditAnywhere, Category = "Blend")
    EAlphaBlendOption BlendOption = UE::Anim::DefaultBlendOption;
 
    bool bNeedsToResetAlpha;
 
    bool bNeedsToResetBlendTime;
 
    mutable bool bNeedsToResetCachedDesiredBlendedValue;
 
    mutable float CachedDesiredBlendedValue;
};
 
#if WITH_EDITORONLY_DATA
template<> struct TStructOpsTypeTraits<FAlphaBlendArgs> : public TStructOpsTypeTraitsBase2<FAlphaBlendArgs>
{
    enum
    {
        WithSerializer = true,
        WithStructuredSerializer = true,
    };
};
 
 
template<> struct TStructOpsTypeTraits<FAlphaBlend> : public TStructOpsTypeTraitsBase2<FAlphaBlend>
{
    enum
    {
        WithSerializer = true,
        WithStructuredSerializer = true,
    };
};
#endif //#if WITH_EDITORONLY_DATA