HorizonTweenEvent.h

Go to the documentation of this file.

// Created by dorgon, All Rights Reserved.
// email: dorgonman@hotmail.com
// blog: dorgon.horizon-studio.net

#pragma once

#include "Object.h"
#include "Function.h"
#include "Horizon/TweenSystem/Event/ParamEvent/HorizonTweenEventParameters.h"
#include "Horizon/TweenSystem/Event/HorizonTweenEventMacro.h"
#include "Horizon/TweenSystem/HorizonTweenFunctionLibrary.h"

#include "Kismet/BlueprintAsyncActionBase.h"


#include "HorizonTweenEvent.generated.h"


class AHorizonTweenSystem;

//namespace EUMGSequencePlayMode





DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnHorizonTweenEvent, UHorizonTweenEvent*, pTweenEvent);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnHorizonTweenEventNative, UHorizonTweenEvent*);
UCLASS(BlueprintType, Blueprintable)
class HORIZONTWEEN_API UHorizonTweenEvent : public UBlueprintAsyncActionBase
{
    
    
    GENERATED_BODY()



protected:
    enum class ETweenEvent {
        InitProcess,
        Processing,
        Finished
    };
public:
    UHorizonTweenEvent();
    virtual ~UHorizonTweenEvent();

    template <typename TDerivedPtr, typename TEventParam>
    FORCEINLINE void InitEvent(const FHorizonTweenEventParameters& eventParam, 
        TEventParam&& eventImplementParam) {
        SetTweenEventParam(eventParam);
        static_cast<TDerivedPtr>(this)->SetEventParam_Implementation(Forward<TEventParam>(eventImplementParam));
    };

    template <typename TDerivedPtr, typename TEventParam>
    const TEventParam& GetEventParam() {
        return static_cast<TDerivedPtr>(this)->GetEventParam_Implementation();
    };

public: //delegate
    // for blueprint
    UPROPERTY(BlueprintAssignable, Category = "HorizonPlugin|TweenEvent")
    FOnHorizonTweenEvent OnTweenStart;
    UPROPERTY(BlueprintAssignable, Category = "HorizonPlugin|TweenEvent")
    FOnHorizonTweenEvent OnTweenUpdate;
    UPROPERTY(BlueprintAssignable, Category = "HorizonPlugin|TweenEvent")
    FOnHorizonTweenEvent OnTweenLoop;
    UPROPERTY(BlueprintAssignable, Category = "HorizonPlugin|TweenEvent")
    FOnHorizonTweenEvent OnTweenFinished;

    // for c++ callback binding
    FOnHorizonTweenEventNative OnTweenStartNative;
    FOnHorizonTweenEventNative OnTweenUpdateNative;
    FOnHorizonTweenEventNative OnTweenLoopNative;
    FOnHorizonTweenEventNative OnTweenFinishedNative;

protected:
    virtual void TweenStart();
    virtual void TweenUpdate();
    virtual void TweenLoop();
    virtual void TweenFinished();



    
public:
    virtual void Init(AHorizonTweenSystem* pTweenSystem);

    virtual void         Processing(float DeltaTime);// PURE_VIRTUAL(UHorizonTweenEvent::Processing, );
    void                 SetEventStatus(ETweenEvent eventStatus);
    ETweenEvent          GetEventStatus() { return EventStatus; };
    bool                 IsFinished() { return (ETweenEvent::Finished == EventStatus); };
    bool                 IsPlaying() { return !bPause; }

    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    float GetCurrentDuration() { return CurrentDuration; };
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    float GetCurrentAlpha();// { return CurrentAlpha; };
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    float GetCurrentNumOfLoop() { return CurrentNumOfLoop; };

    void SetTweenEventParam(const FHorizonTweenEventParameters& param) { TweenEventParam = param; };
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    FHorizonTweenEventParameters& GetTweenEventParam() {return TweenEventParam;}



protected: //TweenEventImplement
    template <typename THorizonTweenEventParameter, typename TReturn>
    TReturn GetTweenStart(const THorizonTweenEventParameter& paramImpl,
        TFunction<TReturn()> getDefaultValue) {
        TReturn result;

        if (paramImpl.TweenStartList.Num() == 0) {
            result = getDefaultValue();
        }
        else {
            int currentNumOfLoop = GetCurrentNumOfLoop();
            if (paramImpl.bLoopTweenList) {
                currentNumOfLoop = currentNumOfLoop % paramImpl.TweenStartList.Num();
            }

            if (currentNumOfLoop < paramImpl.TweenStartList.Num()) {
                result = paramImpl.TweenStartList[currentNumOfLoop];
            }
            else {
                result = paramImpl.TweenStartList.Last();
            }
        }
        
        return result;
    }


    template <typename THorizonTweenEventParameter, typename TReturn>
    TReturn GetTweenEnd(const THorizonTweenEventParameter& paramImpl,
        TFunction<TReturn()> getDefaultValue) {
        TReturn result;

        if (paramImpl.TweenEndList.Num() == 0) {
            result = getDefaultValue();
        }
        else {
            int currentNumOfLoop = GetCurrentNumOfLoop();
            if (paramImpl.bLoopTweenList) {
                currentNumOfLoop = currentNumOfLoop % paramImpl.TweenEndList.Num();
            }

            if (currentNumOfLoop < paramImpl.TweenEndList.Num()) {
                result = paramImpl.TweenEndList[currentNumOfLoop];
            }
            else {
                result = paramImpl.TweenEndList.Last();
            }
        }

        return result;
    }



    template <typename THorizonTweenEventParameter, typename TReturn>
    TReturn GetTweenLerpValue(const THorizonTweenEventParameter& paramImpl,
        TFunction<TReturn()> getDefaultValue) {
        auto currentAlpha = GetCurrentAlpha();
        if (paramImpl.bUseCustomCurve)
        {
            currentAlpha = paramImpl.CustomTweenCurve.Eval(GetCurrentAlpha());
        }


        auto tweenStart = GetTweenStart<decltype(paramImpl), TReturn>(paramImpl,
            getDefaultValue);


        auto tweenEnd = GetTweenEnd<decltype(paramImpl), TReturn>(paramImpl,
            getDefaultValue);

        auto& tweenEventParam = GetTweenEventParam();
        auto result = UHorizonTweenFunctionLibrary::Lerp<TReturn>(tweenEventParam.LerpMode,
            tweenStart, tweenEnd, currentAlpha, tweenEventParam.LerpModeExtraParameterList);
        return result;
    };
public:
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    virtual void Play();
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    virtual void Stop();
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    virtual void Pause();
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    virtual void Resume();

    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    virtual void Finish(bool bTweenToEnd);

    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    void SetFreeze(bool b) {bFreeze = b;};
    UFUNCTION(BlueprintCallable, Category = "HorizonPlugin|TweenEvent")
    bool IsFreeze() {return bFreeze;}






private:
    ETweenEvent EventStatus;
    FHorizonTweenEventParameters TweenEventParam;

    TWeakObjectPtr<AHorizonTweenSystem> TweenSystemWeakPtr;
private:
    float DelayCurrentDuration;
    float CurrentAlpha;
    float CurrentDuration;
    int CurrentNumOfLoop;
    bool bPause;

    //if true, only call TweenUpdate when process tween event  
    bool bFreeze;


};