MovieSceneEvaluationTreeFormatter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Map.h"
#include "Containers/StringFwd.h"
#include "Delegates/Delegate.h"
#include "Delegates/DelegateCombinations.h"
#include "Evaluation/MovieSceneEvaluationTree.h"
#include "Misc/StringBuilder.h"
#include "MovieSceneFwd.h"
#include "MovieSceneTimeHelpers.h"
#include "Templates/Tuple.h"
 
#if !NO_LOGGING
 
template<typename DataType>
struct TMovieSceneEvaluationTreeFormatter
{
    DECLARE_DELEGATE_TwoParams(FOnFormatData, const DataType&, TStringBuilder<256>&);
 
    const TMovieSceneEvaluationTree<DataType>& Tree;
 
    struct FLogRowItem
    {
        int32 ParentRowItemIndex = INDEX_NONE;
        const FMovieSceneEvaluationTreeNode* Node = nullptr;
        int32 Width = 0;
        int32 ChildrenWidthTotal = 0;
        int32 LeftOffset = 0;
    };
 
    using FLogRow = TArray<FLogRowItem>;
    TArray<FLogRow> LogRows;
 
    using FDataIndex = TTuple<int32, int32>;
    using FDataInfo = TTuple<int32, TRange<FFrameNumber>>;
    TMap<FDataIndex, FDataInfo> DataIndices;
 
    int32 ParentItemMargin = 8;
 
    FOnFormatData DataFormatter;
    
    TMovieSceneEvaluationTreeFormatter(const TMovieSceneEvaluationTree<DataType>& InTree)
        : Tree(InTree)
    {}
 
    void LogTree()
    {
        LogRows.Reset();
        DataIndices.Reset();
 
        BuildLogRows(INDEX_NONE, &Tree.RootNode, 0);
        AccumulateWidths();
        AccumulateLeftOffsets();
        OutputLogRows();
 
        OutputData();
    }
 
private:
    void BuildLogRows(int32 InParentRowItemIndex, const FMovieSceneEvaluationTreeNode* InNode, int32 InDepth)
    {
        if (LogRows.Num() <= InDepth)
        {
            LogRows.SetNum(InDepth + 1);
        }
        FLogRow& LogRow = LogRows[InDepth];
 
        TArrayView<const DataType> NodeData = Tree.GetDataForSingleNode(*InNode);
        const int32 NodeWidth = GetItemMinWidth(NodeData.Num());
        const int32 CurItemIndex = LogRow.Add(FLogRowItem{InParentRowItemIndex, InNode, NodeWidth});
 
        if (InNode->ChildrenID.IsValid())
        {
            TArrayView<const FMovieSceneEvaluationTreeNode> ChildNodes = Tree.ChildNodes.Get(InNode->ChildrenID);
            for (const FMovieSceneEvaluationTreeNode& ChildNode : ChildNodes)
            {
                BuildLogRows(CurItemIndex, &ChildNode, InDepth + 1);
            }
        }
    }
 
    void AccumulateWidths()
    {
        for (int32 RowIndex = LogRows.Num() - 1; RowIndex >= 0; --RowIndex)
        {
            FLogRow& LogRow = LogRows[RowIndex];
 
            if (RowIndex > 0)
            {
                FLogRow& ParentLogRow = LogRows[RowIndex - 1];
 
                for (FLogRowItem& RowItem : LogRow)
                {
                    if (RowItem.ChildrenWidthTotal > 0)
                    {
                        RowItem.Width = FMath::Max(RowItem.Width, RowItem.ChildrenWidthTotal + ParentItemMargin);
                    }
 
                    if (ensure(ParentLogRow.IsValidIndex(RowItem.ParentRowItemIndex)))
                    {
                        FLogRowItem& ParentRowItem = ParentLogRow[RowItem.ParentRowItemIndex];
                        ParentRowItem.ChildrenWidthTotal += RowItem.Width;
                    }
                }
            }
            else
            {
                for (FLogRowItem& RowItem : LogRow)
                {
                    if (RowItem.ChildrenWidthTotal > 0)
                    {
                        RowItem.Width = FMath::Max(RowItem.Width, RowItem.ChildrenWidthTotal + ParentItemMargin);
                    }
                }
            }
        }
    }
 
    void AccumulateLeftOffsets()
    {
        for (int32 RowIndex = 1; RowIndex < LogRows.Num(); ++RowIndex)
        {
            FLogRow& LogRow = LogRows[RowIndex];
            FLogRow& ParentLogRow = LogRows[RowIndex - 1];
 
            int32 CurParentRowItemIndex = INDEX_NONE;
            int32 NextLeftOffset = 0;
 
            for (int32 ItemIndex = 0; ItemIndex < LogRow.Num(); ++ItemIndex)
            {
                FLogRowItem& RowItem = LogRow[ItemIndex];
                if (ensure(ParentLogRow.IsValidIndex(RowItem.ParentRowItemIndex)))
                {
                    FLogRowItem& ParentRowItem = ParentLogRow[RowItem.ParentRowItemIndex];
 
                    if (RowItem.ParentRowItemIndex != CurParentRowItemIndex)
                    {
                        NextLeftOffset = ParentRowItem.LeftOffset + ParentItemMargin / 2;
                        CurParentRowItemIndex = RowItem.ParentRowItemIndex;
                    }
 
                    RowItem.LeftOffset = NextLeftOffset;
                    NextLeftOffset += RowItem.Width;
                }
            }
        }
    }
 
    void OutputLogRows()
    {
        TStringBuilder<1024> Builder;
 
        for (const FLogRow& LogRow : LogRows)
        {
            Builder.Reset();
 
            for (const FLogRowItem& RowItem : LogRow)
            {
                // Indent
                const int32 CurLeftOffset = Builder.Len();
                ensure(RowItem.LeftOffset >= CurLeftOffset);
                int32 IndentWidth = FMath::Max(0, RowItem.LeftOffset - CurLeftOffset);
                for (int32 Index = 0; Index < IndentWidth; ++Index)
                {
                    Builder.Append(TEXT(" "));
                }
 
                // Build display string: [====== 0,1,2 ======]
                const FString DataString = LexToStringAllDataIndexes(RowItem.Node);
 
                const int32 Padding = FMath::Max(0, RowItem.Width - DataString.Len() - 4);
                const int32 PaddingLeft = Padding / 2;
                const int32 PaddingRight = Padding - PaddingLeft;
 
                Builder.Append(TEXT("["));
                for (int32 Index = 0; Index < PaddingLeft; ++Index)
                {
                    Builder.Append(TEXT("="));
                }
                Builder.Append(TEXT(" "));
 
                Builder.Append(DataString);
                
                Builder.Append(TEXT(" "));
                for (int32 Index = 0; Index < PaddingLeft; ++Index)
                {
                    Builder.Append(TEXT("="));
                }
                Builder.Append(TEXT("]"));
            }
 
            FString RowString(Builder.ToString());
            UE_LOG(LogMovieScene, Log, TEXT("%s"), *RowString);
        }
    }
 
    void OutputData()
    {
        if (!DataFormatter.IsBound())
        {
            UE_LOG(LogMovieScene, Log, TEXT("No data formatter provided."));
            return;
        }
 
        FMovieSceneEvaluationTreeNode Dummy;
        TStringBuilder<256> DataStringBuilder;
 
        for (auto It : DataIndices)
        {
            DataStringBuilder.Reset();
            Dummy.DataID.EntryIndex = It.Key.template Get<0>();
            TArrayView<const DataType> DataView = Tree.GetDataForSingleNode(Dummy);
            const int32 DataIndex = It.Key.template Get<1>();
            if (ensure(DataView.IsValidIndex(DataIndex)))
            {
                const FDataInfo DataInfo = It.Value;
 
                DataStringBuilder.Appendf(TEXT("%d: "), DataInfo.template Get<0>());
                DataStringBuilder.Appendf(TEXT("%s "), *LexToString(DataInfo.template Get<1>()));
 
                const DataType& Data = DataView[DataIndex];
                DataFormatter.Execute(Data, DataStringBuilder);
                const FString DataString = DataStringBuilder.ToString();
                UE_LOG(LogMovieScene, Log, TEXT("%s"), *DataString);
            }
        }
    }
 
    FString LexToStringAllDataIndexes(const FMovieSceneEvaluationTreeNode* Node)
    {
        TStringBuilder<64> DataBuilder;
        TArrayView<const DataType> DataView = Tree.GetDataForSingleNode(*Node);
        for (int32 Index = 0; Index < DataView.Num(); ++Index)
        {
            if (Index > 0)
            {
                DataBuilder.Append(TEXT(","));
            }
 
            const DataType& Data = DataView[Index];
            const FDataIndex Key(Node->DataID.EntryIndex, Index);
            const FDataInfo DefaultValue(DataIndices.Num(), Node->Range);
            const FDataInfo ActualValue = DataIndices.FindOrAdd(Key, DefaultValue);
            DataBuilder.Append(LexToString(ActualValue.template Get<0>()));
        }
        if (DataView.Num() == 0)
        {
            DataBuilder.Append(TEXT("nil"));
        }
        return DataBuilder.ToString();
    }
 
    static int32 GetItemMinWidth(int32 NumData)
    {
        // [= 0,1,2 =]
        if (NumData > 0)
        {
            return 
                NumData + // unit digit
                FMath::Max(0, NumData - 9) + // tens digit
                FMath::Max(0, NumData - 99) + // hundred digit
                (NumData - 1) + // commas
                4 + 2; // brackets with minimal padding
        }
        else
        {
            return
                3 + // nil
                4 + 2; // brackes with minimal padding
        }
    }
};
 
#endif