MovieSceneMutualComponentInclusivity.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Array.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/MovieSceneMutualComponentInitializer.h"
#include "EntitySystem/MovieSceneEntitySystemDirectedGraph.h"
 
#include <initializer_list>
 
namespace UE::MovieScene
{
 
struct FMutualInclusivityGraph;
struct IMutualComponentInitializer;
 
enum class EComplexInclusivityFilterMode
{
    AllOf,
    AnyOf
};
 
struct FMutuallyInclusiveComponentParams
{
    FMutuallyInclusiveComponentParams()
    {}
 
    TUniquePtr<IMutualComponentInitializer> CustomInitializer;
 
    EMutuallyInclusiveComponentType Type = EMutuallyInclusiveComponentType::Optional;
};
 
 
struct FComplexInclusivityFilter
{
    FComponentMask Mask;
    EComplexInclusivityFilterMode Mode;
 
    FComplexInclusivityFilter(const FComponentMask& InMask, EComplexInclusivityFilterMode InMode)
        : Mask(InMask), Mode(InMode)
    {}
 
    friend uint32 GetTypeHash(const FComplexInclusivityFilter& Filter)
    {
        return HashCombine(GetTypeHash(Filter.Mask), GetTypeHash(Filter.Mode));
    }
 
    friend bool operator==(const FComplexInclusivityFilter& A, const FComplexInclusivityFilter& B)
    {
        return A.Mask == B.Mask && A.Mode == B.Mode;
    }
 
    static FComplexInclusivityFilter All(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        return FComplexInclusivityFilter(FComponentMask(InComponentTypes), EComplexInclusivityFilterMode::AllOf);
    }
 
    static FComplexInclusivityFilter Any(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        return FComplexInclusivityFilter(FComponentMask(InComponentTypes), EComplexInclusivityFilterMode::AnyOf);
    }
 
    UE_DEPRECATED(5.2, "This function will no longer be called")
    bool Match(FComponentMask Input) const
    {
        switch (Mode)
        {
            case EComplexInclusivityFilterMode::AllOf:
                {
                    FComponentMask Temp = Mask;
                    Temp.CombineWithBitwiseAND(Input, EBitwiseOperatorFlags::MaintainSize);
                    return Temp == Mask;
                }
                break;
            case EComplexInclusivityFilterMode::AnyOf:
                {
                    FComponentMask Temp = Mask;
                    Temp.CombineWithBitwiseAND(Input, EBitwiseOperatorFlags::MaintainSize);
                    return Temp.Find(true) != INDEX_NONE;
                }
                break;
            default:
                checkf(false, TEXT("Not implemented"));
                return false;
        }
    }
};
 
 
struct FMutualComponentInitializers
{
    MOVIESCENE_API void Execute(const FEntityRange& Range, const FEntityAllocationWriteContext& WriteContext) const;
 
    void Add(IMutualComponentInitializer* InitializerToAdd);
 
    void Reset();
 
private:
 
    TArray<IMutualComponentInitializer*, TInlineAllocator<2>> Initializers;
};
 
 
struct FMutualInclusivityGraphCommandBuffer
{
    int32 ComputeMutuallyInclusiveComponents(EMutuallyInclusiveComponentType TypesToCompute, const FComponentMask& InMask, FComponentMask& OutMask, FMutualComponentInitializers& OutInitializers) const;
    
    void CheckInvariants() const;
 
private:
 
    // Only FMutualInclusivityGraph can populate this command buffer
    friend FMutualInclusivityGraph;
 
    enum class ECommandType
    {
        Simple,
        Type,
        MatchAny,
        MatchAll,
        ShortCircuit,
        Include,
        Initialize,
    };
 
    struct FSimpleCommand
    {
        FComponentTypeID MatchID;
        FComponentTypeID IncludeID;
    };
    struct FTypeCommand
    {
        uint16 ShortCircuitIndex;
        EMutuallyInclusiveComponentType Type;
    };
 
    struct FMatchCommand
    {
        FComponentTypeID ComponentTypeID;
        uint16 ShortCircuitIndex;
    };
 
    struct FShortCircuitCommand
    {
        uint16 ShortCircuitIndex;
    };
 
    struct FIncludeCommand
    {
        FComponentTypeID ComponentTypeID;
    };
 
    struct FInitializeCommand
    {
        IMutualComponentInitializer* Initializer;
    };
 
    struct FCommand
    {
        FCommand(FSimpleCommand InSimple)                                   : Simple(InSimple),             CommandType(ECommandType::Simple)       {}
        FCommand(FTypeCommand InType)                                       : Type(InType),                 CommandType(ECommandType::Type)         {}
        FCommand(FMatchCommand InMatch, EComplexInclusivityFilterMode Mode) : Match(InMatch),               CommandType(Mode == EComplexInclusivityFilterMode::AllOf ? ECommandType::MatchAll : ECommandType::MatchAny)   {}
        FCommand(FShortCircuitCommand InShortCircuit)                       : ShortCircuit(InShortCircuit), CommandType(ECommandType::ShortCircuit) {}
        FCommand(FIncludeCommand InInclude)                                 : Include(InInclude),           CommandType(ECommandType::Include)      {}
        FCommand(FInitializeCommand InInitialize)                           : Initialize(InInitialize),     CommandType(ECommandType::Initialize)   {}
 
        union
        {
            FTypeCommand         Type;
            FSimpleCommand       Simple;
            FMatchCommand        Match;
            FShortCircuitCommand ShortCircuit;
            FIncludeCommand      Include;
            FInitializeCommand   Initialize;
        };
 
        ECommandType CommandType;
    };
 
    TArray<FCommand> Commands;
};
 
 
struct FMutualInclusivityGraph
{
    void DefineMutualInclusionRule(FComponentTypeID Predicate, std::initializer_list<FComponentTypeID> Dependents);
    void DefineMutualInclusionRule(FComponentTypeID Predicate, std::initializer_list<FComponentTypeID> Dependents, FMutuallyInclusiveComponentParams&& InParams);
 
    void DefineComplexInclusionRule(const FComplexInclusivityFilter& InFilter, std::initializer_list<FComponentTypeID> Dependents);
    void DefineComplexInclusionRule(const FComplexInclusivityFilter& InFilter, std::initializer_list<FComponentTypeID> Dependents, FMutuallyInclusiveComponentParams&& InParams);
 
public:
 
    int32 ComputeMutuallyInclusiveComponents(EMutuallyInclusiveComponentType TypesToCompute, const FComponentMask& InMask, FComponentMask& OutMask, FMutualComponentInitializers& OutInitializers) const;
 
private:
 
    static int32 FindPrerequisiteChainLength(const FDirectedGraph& Graph, FComponentTypeID Component, TMap<FComponentTypeID, int32>& InOutCache);
 
    void ReconstructCommandBuffer() const;
 
private:
 
    struct FIncludes
    {
        void Add(FComponentTypeID Component)
        {
            Includes.AddUnique(Component);
        }
        TArray<FComponentTypeID, TInlineAllocator<1>> Includes;
        TArray<TUniquePtr<IMutualComponentInitializer>> Initializers;
    };
    struct FIncludePair
    {
        FIncludes MandatoryIncludes;
        FIncludes OptionalIncludes;
    };
 
    TMap<FComponentTypeID, FIncludePair> SimpleIncludes;
    TMap<FComplexInclusivityFilter, FIncludePair> ComplexIncludes;
 
    mutable FMutualInclusivityGraphCommandBuffer CommandBuffer;
    mutable bool bCommandBufferInvalidated = false;
};
 
 
} // namespace UE::MovieScene