MovieSceneDecompositionQuery.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/TaskGraphInterfaces.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneIntermediatePropertyValue.h"
#include "HAL/Platform.h"
#include "Templates/Tuple.h"
#include "Templates/TypeCompatibleBytes.h"
#include "UObject/Interface.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
 
#include "MovieSceneDecompositionQuery.generated.h"
 
class UObject;
 
namespace UE
{
namespace MovieScene
{
 
    struct FDecompositionQuery
    {
        TArrayView<const FMovieSceneEntityID> Entities;
 
        bool bConvertFromSourceEntityIDs = true;
 
        UObject* Object = nullptr;
    };
 
    struct FWeightedValue
    {
        double Value = 0.f;
        float Weight = 0.f;
        double BaseValue = 0.f;
        int32 BlendingOrder = INDEX_NONE;
        bool bIsAdditive = true;
        double Get() const
        {
            return (Value - BaseValue) * Weight;
        }
        bool operator<(const FWeightedValue& RHS) const
        {
            return BlendingOrder < RHS.BlendingOrder;
        }
    };
 
    struct FAccumulatedWeightedValue
    {
        double Total = 0.f;
        float TotalWeight = 0.f;
 
        FORCENOINLINE double Normalize() const
        {
            return TotalWeight != 0.f ? Total / TotalWeight : Total;
        }
 
        FORCENOINLINE FAccumulatedWeightedValue& AccumulateThis(const FWeightedValue& Other)
        {
            Total += Other.Get();
            TotalWeight += Other.Weight;
            return *this;
        }
        FORCENOINLINE FAccumulatedWeightedValue& AccumulateThis(const FAccumulatedWeightedValue& Other)
        {
            Total += Other.Total;
            TotalWeight += Other.TotalWeight;
            return *this;
        }
        FORCENOINLINE FAccumulatedWeightedValue Accumulate(const FWeightedValue& Other) const
        {
            return FAccumulatedWeightedValue{ Total + Other.Get(), TotalWeight + Other.Weight };
        }
        FORCENOINLINE FAccumulatedWeightedValue Accumulate(const FAccumulatedWeightedValue& Other) const
        {
            return FAccumulatedWeightedValue{ Total + Other.Total, TotalWeight + Other.TotalWeight };
        }
    };
 
    struct FDecomposedValue
    {
        struct FResult
        {
            FAccumulatedWeightedValue Absolute;
 
            double Additive = 0.f;
        };
 
        FResult Result;
 
        mutable TArray <FWeightedValue> AllDecomposedOverrides;
        TArray<TTuple<FMovieSceneEntityID, FWeightedValue>> DecomposedAbsolutes;
        TArray<TTuple<FMovieSceneEntityID, FWeightedValue>> DecomposedAdditives;
        TArray<TTuple<FMovieSceneEntityID, FWeightedValue>> DecomposedOverrides;
 
 
        MOVIESCENE_API double Recompose(FMovieSceneEntityID EntityID, double CurrentValue, const double* InitialValue) const;
 
    private:
        enum class EDecomposedValueBlendType
        {
            Absolute,
            Additive,
            AdditiveFromBase,
            Override,
        };
 
        void Decompose(
                FMovieSceneEntityID EntityID, 
                FWeightedValue& ThisValue, EDecomposedValueBlendType& OutBlendType, 
                FAccumulatedWeightedValue& Absolutes, 
                FAccumulatedWeightedValue& Additives) const;
    };
 
    // Align results to cache lines so there's no contention between cores
    struct MS_ALIGN(PLATFORM_CACHE_LINE_SIZE) FAlignedDecomposedValue
    {
        FDecomposedValue Value;
    } GCC_ALIGN(PLATFORM_CACHE_LINE_SIZE);
 
    struct FValueDecompositionParams
    {
        FDecompositionQuery Query;
        uint16 DecomposeBlendChannel;
        FMovieSceneEntityID PropertyEntityID;
        FComponentTypeID ResultComponentType;
        FComponentTypeID PropertyTag;
    };
 
    template<typename PropertyType>
    struct TRecompositionResult
    {
        TRecompositionResult(const PropertyType& InCurrentValue, int32 Num)
        {
            while (--Num >= 0)
            {
                Values.Add(InCurrentValue);
            }
        }
 
        TArray<PropertyType, TInlineAllocator<1>> Values;
    };
 
    struct FRecompositionResult
    {
        TArray<FIntermediatePropertyValue, TInlineAllocator<1>> Values;
    };
 
} // namespace MovieScene
} // namespace UE
 
 
UINTERFACE(MinimalAPI)
class UMovieSceneValueDecomposer : public UInterface
{
public:
    GENERATED_BODY()
};
 
class IMovieSceneValueDecomposer
{
public:
    GENERATED_BODY()
 
    virtual FGraphEventRef DispatchDecomposeTask(const UE::MovieScene::FValueDecompositionParams& Params, UE::MovieScene::FAlignedDecomposedValue* Output) = 0;
};