AnimatedAttribute.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Misc/Attribute.h"
#include "AnimatedAttributeManager.h"
#include "AttributeInterpolator.h"
 
template< typename NumericType >
class TAnimatedAttribute : public TAnimatedAttributeBase
{
public:
 
    using FGetter = TDelegate<NumericType()>;
 
protected:
 
    struct FPrivateToken { explicit FPrivateToken() = default; };
    
    TAnimatedAttribute() = delete;
 
public:
 
    template< typename InterpolatorSettings >
    TAnimatedAttribute( FPrivateToken, const InterpolatorSettings& InSettings )
        : Interpolator( MakeUnique<typename InterpolatorSettings::InterpolatorType>(InSettings) )
        , Getter()
        , DesiredValue() 
    {
    }
 
    template< typename InterpolatorSettings, typename OtherType >
    [[nodiscard]] static TSharedRef< TAnimatedAttribute > Create( const InterpolatorSettings& InSettings, OtherType&& InInitialValue )
    {
        TSharedRef< TAnimatedAttribute< NumericType > > Attribute = MakeShared< TAnimatedAttribute< NumericType > >(FPrivateToken{}, InSettings);
        Attribute->Set(Forward<OtherType>(InInitialValue));
        Attribute->Register();
        return Attribute;
    }
    
    template< typename InterpolatorSettings >
    [[nodiscard]] static TSharedRef< TAnimatedAttribute > CreateWithGetter( const InterpolatorSettings& InSettings, const FGetter& InGetter, const TOptional<NumericType>& InDefaultValue = TOptional<NumericType>() )
    {
        TSharedRef< TAnimatedAttribute< NumericType > > Attribute = MakeShared< TAnimatedAttribute< NumericType > >(FPrivateToken{}, InSettings);
        Attribute->Set(InDefaultValue.IsSet() ? InDefaultValue.GetValue() : InGetter.Execute());
        Attribute->Getter = InGetter;
        Attribute->Register();
        return Attribute;
    }
    
    template< typename InterpolatorSettings >
    [[nodiscard]] static TSharedRef< TAnimatedAttribute > CreateWithGetter( const InterpolatorSettings& InSettings, FGetter&& InGetter, const TOptional<NumericType>& InDefaultValue = TOptional<NumericType>() )
    {
        TSharedRef< TAnimatedAttribute< NumericType > > Attribute = MakeShared< TAnimatedAttribute< NumericType > >(FPrivateToken{}, InSettings);
        Attribute->Set(InDefaultValue.IsSet() ? InDefaultValue.GetValue() : InGetter.Execute());
        Attribute->Getter = MoveTemp(InGetter);
        Attribute->Register();
        return Attribute;
    }
    
    template< typename OtherType >
    void Set( const OtherType& InNewValue )
    {
        Getter.Unbind();
        if(DesiredValue.IsSet() && !Interpolator->DesiredValue.IsSet())
        {
            Interpolator->SetValue(DesiredValue.GetValue());
        }
        DesiredValue = InNewValue;
        Interpolator->SetValue(DesiredValue.GetValue());
    }
 
    void Set( NumericType&& InNewValue )
    {
        Getter.Unbind();
        if(DesiredValue.IsSet() && !Interpolator->DesiredValue.IsSet())
        {
            Interpolator->SetValue(DesiredValue.GetValue());
        }
        DesiredValue = InNewValue;
        Interpolator->SetValue(DesiredValue.GetValue());
    }
 
    void SetValueAndStop( const NumericType& InNewValue )
    {
        Set(InNewValue);
        Interpolator->Reset();
    }
    
    void SetValueAndStop( NumericType&& InNewValue )
    {
        Set(Forward<NumericType>(InNewValue));
        Interpolator->Reset();
    }
 
    bool IsSet() const
    {
        return DesiredValue.IsSet() || IsBound();
    }
 
    const NumericType& Get() const
    {
        // If we have a getter delegate, then we'll call that to generate the value
        if( Getter.IsBound() )
        {
            // Call the delegate to get the value.  Note that this will assert if the delegate is not currently
            // safe to call (e.g. object was deleted and we could detect that)
 
            // NOTE: We purposely overwrite our value copy here so that we can return the value by address in
            // the most common case, which is an attribute that doesn't have a delegate bound to it at all.
            DesiredValue = Getter.Execute();
 
            // Update the interpolator
            if(DesiredValue.IsSet())
            {
                Interpolator->SetValue(DesiredValue.GetValue());
            }
        }
 
        // first see if the interpolator has a value
        if(Interpolator->IsSet())
        {
            return Interpolator->Get();
        }
        
        if(DesiredValue.IsSet())
        {
            // Return the stored value
            return DesiredValue.GetValue();
        }
 
        static const NumericType EmptyResult = NumericType();
        return EmptyResult;
    }
 
    const NumericType& Get( const NumericType& DefaultValue ) const
    {
        return IsSet() ? Get() : DefaultValue;
    }
 
    const NumericType& GetDesiredValue() const
    {
        if(DesiredValue.IsSet())
        {
            return DesiredValue.GetValue();
        }
        static const NumericType EmptyResult = NumericType();
        return EmptyResult;
    }
 
    double GetOverAllDeltaTime() const
    {
        return Interpolator->GetOverAllDeltaTime();
    }
 
    TOptional<NumericType> GetDelay() const
    {
        return Interpolator->Delay;
    }
 
    void SetDelayOneShot( double InDelay )
    {
        Interpolator->SetDelayOneShot(InDelay);
    }
 
    void SetTolerance( double Tolerance )
    {
        Interpolator->SetTolerance(Tolerance);
    }
 
    bool IsPlaying() const
    {
        return Interpolator->IsPlaying();
    }
 
    void EnableInterpolation(bool bEnabled = true)
    {
        Interpolator->SetEnabled(bEnabled);
    }
 
    void DisableInterpolation()
    {
        EnableInterpolation(false);
    }
 
    bool IsBound() const
    {
        return Getter.IsBound();
    }
 
    bool IdenticalTo(const TAnimatedAttribute& InOther) const
    {
        if(!Interpolator->IdenticalTo(InOther.Interpolator.Get()))
        {
            return false;
        }
 
        const bool bIsBound = IsBound();
        if ( bIsBound == InOther.IsBound() )
        {
            if ( bIsBound )
            {
                return Getter.GetHandle() == InOther.Getter.GetHandle();
            }
            return IsSet() == InOther.IsSet() && DesiredValue == InOther.DesiredValue;
        }
 
        return false;
    }
 
    /*
     * Returns the delegate to react to the interpolator starting to interpolate
     */
    typename TAttributeInterpolator< NumericType >::FInterpolatorEvent& OnInterpolationStarted()
    {
        return Interpolator->OnInterpolationStarted();
    }
 
    /*
     * Returns the delegate to react to the interpolator ending to interpolate
     */
    typename TAttributeInterpolator< NumericType >::FInterpolatorEvent& OnInterpolationStopped()
    {
        return Interpolator->OnInterpolationStopped();
    }
 
private:
 
    virtual void Tick(float InDeltaTime) override
    {
        if( Getter.IsBound() )
        {
            Interpolator->SetValue(Getter.Execute());
        }
        if(DesiredValue.IsSet())
        {
            Interpolator->SetValue(DesiredValue.GetValue());
        }
        Interpolator->Tick(InDeltaTime);
    }
 
    // We declare ourselves as a friend (templated using OtherType) so we can access members as needed
    template< class OtherType > friend class TAnimatedAttribute;
 
    TUniquePtr< TAttributeInterpolator< NumericType > > Interpolator;
 
    FGetter Getter;
    
    mutable TOptional< NumericType > DesiredValue;
};