MovieScenePiecewiseDoubleBlenderSystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/SortedMap.h"
#include "EntitySystem/MovieSceneBlenderSystem.h"
#include "EntitySystem/MovieSceneCachedEntityFilterResult.h"
#include "EntitySystem/MovieSceneDecompositionQuery.h"
#include "EntitySystem/MovieSceneEntitySystem.h"
 
#include "MovieScenePiecewiseDoubleBlenderSystem.generated.h"
 
namespace UE
{
namespace MovieScene
{
 
struct FBlendResult
{
    double Total = 0.f;
    float Weight = 0.f;
};
 
/* Data for each additive/override section, we don't accumulate until we recieve all of the data*/
struct FAdditveAndOverrideData
{
    bool bIsAdditive;
    double Value;
    float Weight;
    int32 BlendingOrder;
    bool operator<(const FAdditveAndOverrideData& RHS) const
    {
        return BlendingOrder < RHS.BlendingOrder;
    }
};
struct FAdditiveAndOverrides
{
    mutable TSortedMap<int32, FAdditveAndOverrideData> Data;
};
 
struct FAccumulationResult
{
    const FBlendResult* Absolutes = nullptr;
    const FBlendResult* Relatives = nullptr;
    const FBlendResult* Additives = nullptr;
    const FBlendResult* AdditivesFromBase = nullptr;
    const FAdditiveAndOverrides* Overrides = nullptr;
    bool IsValid() const
    {
        return Absolutes || Relatives || Additives || AdditivesFromBase
            || Overrides;
    }
 
    FBlendResult GetAbsoluteResult(uint16 BlendID) const
    {
        return Absolutes ? Absolutes[BlendID] : FBlendResult{};
    }
    FBlendResult GetRelativeResult(uint16 BlendID) const
    {
        return Relatives ? Relatives[BlendID] : FBlendResult{};
    }
    FBlendResult GetAdditiveResult(uint16 BlendID) const
    {
        return Additives ? Additives[BlendID] : FBlendResult{};
    }
    FBlendResult GetAdditiveFromBaseResult(uint16 BlendID) const
    {
        return AdditivesFromBase ? AdditivesFromBase[BlendID] : FBlendResult{};
    }
    FAdditiveAndOverrides GetAdditiveAndOverrideResult(uint16 BlendID)  const
    {
        return Overrides? Overrides[BlendID] : FAdditiveAndOverrides{};
    }
};
 
struct FAdditiveAndOverrideBuffer
{
    TArray<FAdditiveAndOverrides> Values;
};
 
struct FAdditiveFromBaseBuffer
{
    TArray<FBlendResult> Buffer;
    TComponentTypeID<double> BaseComponent;
};
 
struct FAccumulationBuffers
{
    bool IsEmpty() const;
 
    void Reset();
 
    FAccumulationResult FindResults(FComponentTypeID InComponentType) const;
 
    TSortedMap<FComponentTypeID, TArray<FBlendResult>> Absolute;
    TSortedMap<FComponentTypeID, TArray<FBlendResult>> Relative;
    TSortedMap<FComponentTypeID, TArray<FBlendResult>> Additive;
    TSortedMap<FComponentTypeID, FAdditiveFromBaseBuffer> AdditiveFromBase;
    TSortedMap<FComponentTypeID, FAdditiveAndOverrideBuffer> AdditiveAndOverrides;
 
};
 
} // namespace MovieScene
} // namespace UE
 
UCLASS(DisplayName="Weighted per-channel", meta=(Tooltip="Blends each channel of this object's transform as separate scalar components. Useful for blending to/from over-rotated objects (ie, 0 < rotation > 360."), MinimalAPI)
class UMovieScenePiecewiseDoubleBlenderSystem : public UMovieSceneBlenderSystem, public IMovieSceneValueDecomposer
{
public:
    GENERATED_BODY()
 
    MOVIESCENETRACKS_API UMovieScenePiecewiseDoubleBlenderSystem(const FObjectInitializer& ObjInit);
 
    using FMovieSceneEntityID  = UE::MovieScene::FMovieSceneEntityID;
    using FComponentTypeID     = UE::MovieScene::FComponentTypeID;
 
    MOVIESCENETRACKS_API virtual void OnSchedulePersistentTasks(UE::MovieScene::IEntitySystemScheduler* TaskScheduler) override;
    MOVIESCENETRACKS_API virtual void OnRun(FSystemTaskPrerequisites& InPrerequisites, FSystemSubsequentTasks& Subsequents) override;
 
    MOVIESCENETRACKS_API virtual FGraphEventRef DispatchDecomposeTask(const UE::MovieScene::FValueDecompositionParams& Params, UE::MovieScene::FAlignedDecomposedValue* Output) override;
 
private:
 
    void ReinitializeAccumulationBuffers();
    void ZeroAccumulationBuffers();
 
    UE::MovieScene::FAccumulationBuffers AccumulationBuffers;
 
    FComponentMask BlendedResultMask;
 
    FComponentMask BlendedPropertyMask;
 
    UE::MovieScene::FCachedEntityManagerState ChannelRelevancyCache;
 
    TBitArray<> CachedRelevantProperties;
 
    bool bContainsNonPropertyBlends = false;
};