You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
626 lines
24 KiB
C++
626 lines
24 KiB
C++
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "LogVisualizerPCH.h"
|
|
#include "Misc/Base64.h"
|
|
#include "Json.h"
|
|
#include "CollisionDebugDrawingPublic.h"
|
|
#include "LogVisualizerDebugActor.h"
|
|
|
|
#if ENABLE_VISUAL_LOG
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
TSharedPtr<FJsonValue> GenerateJson(FVisualLogEntry* InEntry)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonEntryObject = MakeShareable(new FJsonObject);
|
|
|
|
JsonEntryObject->SetNumberField(VisualLogJson::TAG_TIMESTAMP, InEntry->TimeStamp);
|
|
JsonEntryObject->SetStringField(VisualLogJson::TAG_LOCATION, InEntry->Location.ToString());
|
|
|
|
const int32 StatusCategoryCount = InEntry->Status.Num();
|
|
const FVisualLogStatusCategory* StatusCategory = InEntry->Status.GetData();
|
|
TArray< TSharedPtr<FJsonValue> > JsonStatus;
|
|
JsonStatus.AddZeroed(StatusCategoryCount);
|
|
|
|
for (int32 StatusIdx = 0; StatusIdx < InEntry->Status.Num(); StatusIdx++, StatusCategory++)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonStatusCategoryObject = MakeShareable(new FJsonObject);
|
|
JsonStatusCategoryObject->SetStringField(VisualLogJson::TAG_CATEGORY, StatusCategory->Category);
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonStatusLines;
|
|
JsonStatusLines.AddZeroed(StatusCategory->Data.Num());
|
|
for (int32 LineIdx = 0; LineIdx < StatusCategory->Data.Num(); LineIdx++)
|
|
{
|
|
JsonStatusLines[LineIdx] = MakeShareable(new FJsonValueString(StatusCategory->Data[LineIdx]));
|
|
}
|
|
|
|
JsonStatusCategoryObject->SetArrayField(VisualLogJson::TAG_STATUSLINES, JsonStatusLines);
|
|
JsonStatus[StatusIdx] = MakeShareable(new FJsonValueObject(JsonStatusCategoryObject));
|
|
}
|
|
JsonEntryObject->SetArrayField(VisualLogJson::TAG_STATUS, JsonStatus);
|
|
|
|
const int32 LogLineCount = InEntry->LogLines.Num();
|
|
const FVisualLogLine* LogLine = InEntry->LogLines.GetData();
|
|
TArray< TSharedPtr<FJsonValue> > JsonLines;
|
|
JsonLines.AddZeroed(LogLineCount);
|
|
|
|
for (int32 LogLineIndex = 0; LogLineIndex < LogLineCount; ++LogLineIndex, ++LogLine)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonLogLineObject = MakeShareable(new FJsonObject);
|
|
JsonLogLineObject->SetStringField(VisualLogJson::TAG_CATEGORY, LogLine->Category.ToString());
|
|
JsonLogLineObject->SetNumberField(VisualLogJson::TAG_VERBOSITY, LogLine->Verbosity);
|
|
JsonLogLineObject->SetStringField(VisualLogJson::TAG_LINE, LogLine->Line);
|
|
JsonLogLineObject->SetStringField(VisualLogJson::TAG_TAGNAME, LogLine->TagName.ToString());
|
|
JsonLogLineObject->SetNumberField(VisualLogJson::TAG_USERDATA, LogLine->UserData);
|
|
JsonLines[LogLineIndex] = MakeShareable(new FJsonValueObject(JsonLogLineObject));
|
|
}
|
|
|
|
JsonEntryObject->SetArrayField(VisualLogJson::TAG_LOGLINES, JsonLines);
|
|
|
|
const int32 ElementsToDrawCount = InEntry->ElementsToDraw.Num();
|
|
const FVisualLogShapeElement* Element = InEntry->ElementsToDraw.GetData();
|
|
TArray< TSharedPtr<FJsonValue> > JsonElementsToDraw;
|
|
JsonElementsToDraw.AddZeroed(ElementsToDrawCount);
|
|
|
|
for (int32 ElementIndex = 0; ElementIndex < ElementsToDrawCount; ++ElementIndex, ++Element)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonElementToDrawObject = MakeShareable(new FJsonObject);
|
|
|
|
JsonElementToDrawObject->SetStringField(VisualLogJson::TAG_DESCRIPTION, Element->Description);
|
|
JsonElementToDrawObject->SetStringField(VisualLogJson::TAG_CATEGORY, Element->Category.ToString());
|
|
JsonElementToDrawObject->SetNumberField(VisualLogJson::TAG_VERBOSITY, Element->Verbosity);
|
|
|
|
const int32 EncodedTypeColorSize = uint8(Element->Type) << 24 | Element->Color << 16 | Element->Thicknes;
|
|
JsonElementToDrawObject->SetStringField(VisualLogJson::TAG_TYPECOLORSIZE, FString::Printf(TEXT("%d"), EncodedTypeColorSize));
|
|
|
|
const int32 PointsCount = Element->Points.Num();
|
|
TArray< TSharedPtr<FJsonValue> > JsonStringPoints;
|
|
JsonStringPoints.AddZeroed(PointsCount);
|
|
const FVector* PointToDraw = Element->Points.GetData();
|
|
for (int32 PointIndex = 0; PointIndex < PointsCount; ++PointIndex, ++PointToDraw)
|
|
{
|
|
JsonStringPoints[PointIndex] = MakeShareable(new FJsonValueString(PointToDraw->ToString()));
|
|
}
|
|
JsonElementToDrawObject->SetArrayField(VisualLogJson::TAG_POINTS, JsonStringPoints);
|
|
|
|
JsonElementsToDraw[ElementIndex] = MakeShareable(new FJsonValueObject(JsonElementToDrawObject));
|
|
}
|
|
|
|
JsonEntryObject->SetArrayField(VisualLogJson::TAG_ELEMENTSTODRAW, JsonElementsToDraw);
|
|
|
|
const int32 HistogramSamplesCount = InEntry->HistogramSamples.Num();
|
|
const FVisualLogHistogramSample* Sample = InEntry->HistogramSamples.GetData();
|
|
TArray<TSharedPtr<FJsonValue> > JsonHistogramSamples;
|
|
JsonHistogramSamples.AddZeroed(HistogramSamplesCount);
|
|
|
|
for (int32 SampleIndex = 0; SampleIndex < HistogramSamplesCount; ++SampleIndex, ++Sample)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonSampleObject = MakeShareable(new FJsonObject);
|
|
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_CATEGORY, Sample->Category.ToString());
|
|
JsonSampleObject->SetNumberField(VisualLogJson::TAG_VERBOSITY, Sample->Verbosity);
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_HISTOGRAMSAMPLE, Sample->SampleValue.ToString());
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_HISTOGRAMGRAPHNAME, Sample->GraphName.ToString());
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_HISTOGRAMDATANAME, Sample->DataName.ToString());
|
|
|
|
JsonHistogramSamples[SampleIndex] = MakeShareable(new FJsonValueObject(JsonSampleObject));
|
|
}
|
|
|
|
JsonEntryObject->SetArrayField(VisualLogJson::TAG_HISTOGRAMSAMPLES, JsonHistogramSamples);
|
|
|
|
// generate json from events
|
|
{
|
|
const int32 EventsCount = InEntry->Events.Num();
|
|
TArray<TSharedPtr<FJsonValue> > JsonEventSamples;
|
|
JsonEventSamples.Reserve(HistogramSamplesCount);
|
|
|
|
const FVisualLogHistogramSample* Sample = InEntry->HistogramSamples.GetData();
|
|
for (auto& CurrentEvent : InEntry->Events)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonSampleObject = MakeShareable(new FJsonObject);
|
|
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_CATEGORY, CurrentEvent.Name);
|
|
JsonSampleObject->SetNumberField(VisualLogJson::TAG_VERBOSITY, CurrentEvent.Verbosity);
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_TAGNAME, CurrentEvent.TagName.ToString());
|
|
JsonSampleObject->SetNumberField(VisualLogJson::TAG_USERDATA, CurrentEvent.UserData);
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_DESCRIPTION, CurrentEvent.UserFriendlyDesc);
|
|
JsonSampleObject->SetNumberField(VisualLogJson::TAG_COUNTER, CurrentEvent.Counter);
|
|
|
|
TArray<TSharedPtr<FJsonValue> > JsonEventTags;
|
|
JsonEventTags.Reserve(HistogramSamplesCount);
|
|
for (auto& CurrentTag : CurrentEvent.EventTags)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonEventObject = MakeShareable(new FJsonObject);
|
|
JsonEventObject->SetStringField(VisualLogJson::TAG_EVENTNAME, CurrentTag.Key.ToString());
|
|
JsonEventObject->SetNumberField(VisualLogJson::TAG_COUNTER, CurrentTag.Value);
|
|
|
|
JsonEventTags.Add(MakeShareable(new FJsonValueObject(JsonEventObject)));
|
|
}
|
|
JsonSampleObject->SetArrayField(VisualLogJson::TAG_EVENTAGS, JsonEventTags);
|
|
|
|
JsonEventSamples.Add(MakeShareable(new FJsonValueObject(JsonSampleObject)));
|
|
}
|
|
|
|
JsonEntryObject->SetArrayField(VisualLogJson::TAG_EVENTSAMPLES, JsonEventSamples);
|
|
}
|
|
|
|
int32 DataBlockIndex = 0;
|
|
TArray<TSharedPtr<FJsonValue> > JasonDataBlocks;
|
|
JasonDataBlocks.AddZeroed(InEntry->DataBlocks.Num());
|
|
for (const auto CurrentData : InEntry->DataBlocks)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonSampleObject = MakeShareable(new FJsonObject);
|
|
|
|
TArray<uint8> CompressedData;
|
|
const int32 UncompressedSize = CurrentData.Data.Num();
|
|
const int32 HeaderSize = sizeof(int32);
|
|
CompressedData.Init(0, HeaderSize + FMath::TruncToInt(1.1f * UncompressedSize));
|
|
|
|
int32 CompressedSize = CompressedData.Num() - HeaderSize;
|
|
uint8* DestBuffer = CompressedData.GetData();
|
|
FMemory::Memcpy(DestBuffer, &UncompressedSize, HeaderSize);
|
|
DestBuffer += HeaderSize;
|
|
|
|
FCompression::CompressMemory((ECompressionFlags)(COMPRESS_ZLIB | COMPRESS_BiasMemory), (void*)DestBuffer, CompressedSize, (void*)CurrentData.Data.GetData(), UncompressedSize);
|
|
CompressedData.SetNum(CompressedSize + HeaderSize, true);
|
|
const FString CurrentDataAsString = FBase64::Encode(CompressedData);
|
|
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_CATEGORY, CurrentData.Category.ToString());
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_TAGNAME, CurrentData.TagName.ToString());
|
|
JsonSampleObject->SetStringField(VisualLogJson::TAG_DATABLOCK_DATA, CurrentDataAsString);
|
|
JsonSampleObject->SetNumberField(VisualLogJson::TAG_VERBOSITY, CurrentData.Verbosity);
|
|
|
|
JasonDataBlocks[DataBlockIndex++] = MakeShareable(new FJsonValueObject(JsonSampleObject));
|
|
}
|
|
JsonEntryObject->SetArrayField(VisualLogJson::TAG_DATABLOCK, JasonDataBlocks);
|
|
|
|
return MakeShareable(new FJsonValueObject(JsonEntryObject));
|
|
}
|
|
|
|
TSharedPtr<FVisualLogEntry> JsonToVisualLogEntry(TSharedPtr<FJsonValue> FromJson)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonEntryObject = FromJson->AsObject();
|
|
if (JsonEntryObject.IsValid() == false)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
TSharedPtr<FVisualLogEntry> VisLogEntry = MakeShareable(new FVisualLogEntry());
|
|
VisLogEntry->TimeStamp = JsonEntryObject->GetNumberField(VisualLogJson::TAG_TIMESTAMP);
|
|
VisLogEntry->Location.InitFromString(JsonEntryObject->GetStringField(VisualLogJson::TAG_LOCATION));
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonStatus = JsonEntryObject->GetArrayField(VisualLogJson::TAG_STATUS);
|
|
if (JsonStatus.Num() > 0)
|
|
{
|
|
VisLogEntry->Status.AddZeroed(JsonStatus.Num());
|
|
for (int32 StatusIndex = 0; StatusIndex < JsonStatus.Num(); ++StatusIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonStatusCategory = JsonStatus[StatusIndex]->AsObject();
|
|
if (JsonStatusCategory.IsValid())
|
|
{
|
|
VisLogEntry->Status[StatusIndex].Category = JsonStatusCategory->GetStringField(VisualLogJson::TAG_CATEGORY);
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonStatusLines = JsonStatusCategory->GetArrayField(VisualLogJson::TAG_STATUSLINES);
|
|
if (JsonStatusLines.Num() > 0)
|
|
{
|
|
VisLogEntry->Status[StatusIndex].Data.AddZeroed(JsonStatusLines.Num());
|
|
for (int32 LineIdx = 0; LineIdx < JsonStatusLines.Num(); LineIdx++)
|
|
{
|
|
VisLogEntry->Status[StatusIndex].Data.Add(JsonStatusLines[LineIdx]->AsString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonLines = JsonEntryObject->GetArrayField(VisualLogJson::TAG_LOGLINES);
|
|
if (JsonLines.Num() > 0)
|
|
{
|
|
VisLogEntry->LogLines.AddZeroed(JsonLines.Num());
|
|
for (int32 LogLineIndex = 0; LogLineIndex < JsonLines.Num(); ++LogLineIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonLogLine = JsonLines[LogLineIndex]->AsObject();
|
|
if (JsonLogLine.IsValid())
|
|
{
|
|
VisLogEntry->LogLines[LogLineIndex].Category = FName(*(JsonLogLine->GetStringField(VisualLogJson::TAG_CATEGORY)));
|
|
VisLogEntry->LogLines[LogLineIndex].Verbosity = TEnumAsByte<ELogVerbosity::Type>((uint8)FMath::TruncToInt(JsonLogLine->GetNumberField(VisualLogJson::TAG_VERBOSITY)));
|
|
VisLogEntry->LogLines[LogLineIndex].Line = JsonLogLine->GetStringField(VisualLogJson::TAG_LINE);
|
|
VisLogEntry->LogLines[LogLineIndex].TagName = FName(*(JsonLogLine->GetStringField(VisualLogJson::TAG_TAGNAME)));
|
|
VisLogEntry->LogLines[LogLineIndex].UserData = (int64)(JsonLogLine->GetNumberField(VisualLogJson::TAG_USERDATA));
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonElementsToDraw = JsonEntryObject->GetArrayField(VisualLogJson::TAG_ELEMENTSTODRAW);
|
|
if (JsonElementsToDraw.Num() > 0)
|
|
{
|
|
VisLogEntry->ElementsToDraw.Reserve(JsonElementsToDraw.Num());
|
|
for (int32 ElementIndex = 0; ElementIndex < JsonElementsToDraw.Num(); ++ElementIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonElementObject = JsonElementsToDraw[ElementIndex]->AsObject();
|
|
if (JsonElementObject.IsValid())
|
|
{
|
|
FVisualLogShapeElement& Element = VisLogEntry->ElementsToDraw[VisLogEntry->ElementsToDraw.Add(FVisualLogShapeElement())];
|
|
|
|
Element.Description = JsonElementObject->GetStringField(VisualLogJson::TAG_DESCRIPTION);
|
|
Element.Category = FName(*(JsonElementObject->GetStringField(VisualLogJson::TAG_CATEGORY)));
|
|
Element.Verbosity = TEnumAsByte<ELogVerbosity::Type>((uint8)FMath::TruncToInt(JsonElementObject->GetNumberField(VisualLogJson::TAG_VERBOSITY)));
|
|
|
|
// Element->Type << 24 | Element->Color << 16 | Element->Thicknes;
|
|
int32 EncodedTypeColorSize = 0;
|
|
TTypeFromString<int32>::FromString(EncodedTypeColorSize, *(JsonElementObject->GetStringField(VisualLogJson::TAG_TYPECOLORSIZE)));
|
|
Element.Type = EVisualLoggerShapeElement(EncodedTypeColorSize >> 24);
|
|
Element.Color = (EncodedTypeColorSize << 8) >> 24;
|
|
Element.Thicknes = (EncodedTypeColorSize << 16) >> 16;
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonPoints = JsonElementObject->GetArrayField(VisualLogJson::TAG_POINTS);
|
|
if (JsonPoints.Num() > 0)
|
|
{
|
|
Element.Points.AddUninitialized(JsonPoints.Num());
|
|
for (int32 PointIndex = 0; PointIndex < JsonPoints.Num(); ++PointIndex)
|
|
{
|
|
Element.Points[PointIndex].InitFromString(JsonPoints[PointIndex]->AsString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonHistogramSamples = JsonEntryObject->GetArrayField(VisualLogJson::TAG_HISTOGRAMSAMPLES);
|
|
if (JsonHistogramSamples.Num() > 0)
|
|
{
|
|
VisLogEntry->HistogramSamples.Reserve(JsonHistogramSamples.Num());
|
|
for (int32 SampleIndex = 0; SampleIndex < JsonHistogramSamples.Num(); ++SampleIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonSampleObject = JsonHistogramSamples[SampleIndex]->AsObject();
|
|
if (JsonSampleObject.IsValid())
|
|
{
|
|
FVisualLogHistogramSample& Sample = VisLogEntry->HistogramSamples[VisLogEntry->HistogramSamples.Add(FVisualLogHistogramSample())];
|
|
|
|
Sample.Category = FName(*(JsonSampleObject->GetStringField(VisualLogJson::TAG_CATEGORY)));
|
|
Sample.Verbosity = TEnumAsByte<ELogVerbosity::Type>((uint8)FMath::TruncToInt(JsonSampleObject->GetNumberField(VisualLogJson::TAG_VERBOSITY)));
|
|
Sample.GraphName = FName(*(JsonSampleObject->GetStringField(VisualLogJson::TAG_HISTOGRAMGRAPHNAME)));
|
|
Sample.DataName = FName(*(JsonSampleObject->GetStringField(VisualLogJson::TAG_HISTOGRAMDATANAME)));
|
|
Sample.SampleValue.InitFromString(JsonSampleObject->GetStringField(VisualLogJson::TAG_HISTOGRAMSAMPLE));
|
|
}
|
|
}
|
|
}
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonEventSamples = JsonEntryObject->GetArrayField(VisualLogJson::TAG_EVENTSAMPLES);
|
|
if (JsonEventSamples.Num() > 0)
|
|
{
|
|
VisLogEntry->Events.Reserve(JsonEventSamples.Num());
|
|
for (int32 SampleIndex = 0; SampleIndex < JsonEventSamples.Num(); ++SampleIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonSampleObject = JsonEventSamples[SampleIndex]->AsObject();
|
|
if (JsonSampleObject.IsValid())
|
|
{
|
|
FVisualLogEvent& Event = VisLogEntry->Events[VisLogEntry->Events.Add(FVisualLogEvent())];
|
|
Event.Name = JsonSampleObject->GetStringField(VisualLogJson::TAG_CATEGORY);
|
|
Event.Verbosity = TEnumAsByte<ELogVerbosity::Type>((uint8)FMath::TruncToInt(JsonSampleObject->GetNumberField(VisualLogJson::TAG_VERBOSITY)));
|
|
Event.TagName = FName(*(JsonSampleObject->GetStringField(VisualLogJson::TAG_TAGNAME)));
|
|
Event.UserData = (int64)(JsonSampleObject->GetNumberField(VisualLogJson::TAG_USERDATA));
|
|
Event.UserFriendlyDesc = JsonSampleObject->GetStringField(VisualLogJson::TAG_DESCRIPTION);
|
|
Event.Counter = (int64)(JsonSampleObject->GetNumberField(VisualLogJson::TAG_COUNTER));
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonEventTags = JsonSampleObject->GetArrayField(VisualLogJson::TAG_EVENTAGS);
|
|
if (JsonEventTags.Num() > 0)
|
|
{
|
|
Event.EventTags.Reserve(JsonEventSamples.Num());
|
|
for (int32 TagIndex = 0; TagIndex < JsonEventTags.Num(); ++TagIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonTagObject = JsonEventTags[TagIndex]->AsObject();
|
|
if (JsonTagObject.IsValid())
|
|
{
|
|
FString TagName = JsonTagObject->GetStringField(VisualLogJson::TAG_EVENTNAME);
|
|
int32 TagCounter = JsonTagObject->GetNumberField(VisualLogJson::TAG_COUNTER);
|
|
Event.EventTags.Add(*TagName, TagCounter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JasonDataBlocks = JsonEntryObject->GetArrayField(VisualLogJson::TAG_DATABLOCK);
|
|
if (JasonDataBlocks.Num() > 0)
|
|
{
|
|
VisLogEntry->DataBlocks.Reserve(JasonDataBlocks.Num());
|
|
for (int32 SampleIndex = 0; SampleIndex < JasonDataBlocks.Num(); ++SampleIndex)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonSampleObject = JasonDataBlocks[SampleIndex]->AsObject();
|
|
if (JsonSampleObject.IsValid())
|
|
{
|
|
FVisualLogDataBlock& Sample = VisLogEntry->DataBlocks[VisLogEntry->DataBlocks.Add(FVisualLogDataBlock())];
|
|
Sample.TagName = FName(*(JsonSampleObject->GetStringField(VisualLogJson::TAG_TAGNAME)));
|
|
Sample.Category = FName(*(JsonSampleObject->GetStringField(VisualLogJson::TAG_CATEGORY)));
|
|
Sample.Verbosity = TEnumAsByte<ELogVerbosity::Type>((uint8)FMath::TruncToInt(JsonSampleObject->GetNumberField(VisualLogJson::TAG_VERBOSITY)));
|
|
|
|
// decode data from Base64 string
|
|
const FString DataBlockAsCompressedString = JsonSampleObject->GetStringField(VisualLogJson::TAG_DATABLOCK_DATA);
|
|
TArray<uint8> CompressedDataBlock;
|
|
FBase64::Decode(DataBlockAsCompressedString, CompressedDataBlock);
|
|
|
|
// uncompress decoded data to get final TArray<uint8>
|
|
int32 UncompressedSize = 0;
|
|
const int32 HeaderSize = sizeof(int32);
|
|
uint8* SrcBuffer = (uint8*)CompressedDataBlock.GetData();
|
|
FMemory::Memcpy(&UncompressedSize, SrcBuffer, HeaderSize);
|
|
SrcBuffer += HeaderSize;
|
|
const int32 CompressedSize = CompressedDataBlock.Num() - HeaderSize;
|
|
|
|
Sample.Data.AddZeroed(UncompressedSize);
|
|
FCompression::UncompressMemory((ECompressionFlags)(COMPRESS_ZLIB), (void*)Sample.Data.GetData(), UncompressedSize, SrcBuffer, CompressedSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
return VisLogEntry;
|
|
}
|
|
//----------------------------------------------------------------------//
|
|
// FActorsVisLog
|
|
//----------------------------------------------------------------------//
|
|
FActorsVisLog::FActorsVisLog(FName InName, TArray<TWeakObjectPtr<UObject> >* Children)
|
|
: Name(InName)
|
|
{
|
|
Entries.Reserve(VisLogInitialSize);
|
|
}
|
|
|
|
FActorsVisLog::FActorsVisLog(const class UObject* Object, TArray<TWeakObjectPtr<UObject> >* Children)
|
|
: Name(Object->GetFName())
|
|
, FullName(Object->GetFullName())
|
|
{
|
|
Entries.Reserve(VisLogInitialSize);
|
|
}
|
|
|
|
FActorsVisLog::FActorsVisLog(TSharedPtr<FJsonValue> FromJson)
|
|
{
|
|
TSharedPtr<FJsonObject> JsonLogObject = FromJson->AsObject();
|
|
if (JsonLogObject.IsValid() == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Name = FName(*JsonLogObject->GetStringField(VisualLogJson::TAG_NAME));
|
|
FullName = JsonLogObject->GetStringField(VisualLogJson::TAG_FULLNAME);
|
|
|
|
TArray< TSharedPtr<FJsonValue> > JsonEntries = JsonLogObject->GetArrayField(VisualLogJson::TAG_ENTRIES);
|
|
if (JsonEntries.Num() > 0)
|
|
{
|
|
Entries.AddZeroed(JsonEntries.Num());
|
|
for (int32 EntryIndex = 0; EntryIndex < JsonEntries.Num(); ++EntryIndex)
|
|
{
|
|
Entries[EntryIndex] = JsonToVisualLogEntry(JsonEntries[EntryIndex]);
|
|
}
|
|
}
|
|
}
|
|
|
|
TSharedPtr<FJsonValue> FActorsVisLog::ToJson() const
|
|
{
|
|
TSharedPtr<FJsonObject> JsonLogObject = MakeShareable(new FJsonObject);
|
|
|
|
JsonLogObject->SetStringField(VisualLogJson::TAG_NAME, Name.ToString());
|
|
JsonLogObject->SetStringField(VisualLogJson::TAG_FULLNAME, FullName);
|
|
|
|
const TSharedPtr<FVisualLogEntry>* Entry = Entries.GetData();
|
|
const int32 EntryCount = Entries.Num();
|
|
TArray< TSharedPtr<FJsonValue> > JsonLogEntries;
|
|
JsonLogEntries.AddZeroed(EntryCount);
|
|
|
|
for (int32 EntryIndex = 0; EntryIndex < EntryCount; ++EntryIndex, ++Entry)
|
|
{
|
|
JsonLogEntries[EntryIndex] = GenerateJson((*Entry).Get());
|
|
}
|
|
|
|
JsonLogObject->SetArrayField(VisualLogJson::TAG_ENTRIES, JsonLogEntries);
|
|
|
|
return MakeShareable(new FJsonValueObject(JsonLogObject));
|
|
}
|
|
|
|
void FLogVisualizer::SummonUI(UWorld* InWorld)
|
|
{
|
|
UE_LOG(LogLogVisualizer, Log, TEXT("Opening LogVisualizer..."));
|
|
|
|
if( IsInGameThread() )
|
|
{
|
|
if (LogWindow.IsValid() && World.IsValid() && World == InWorld)
|
|
{
|
|
return;
|
|
}
|
|
|
|
World = InWorld;
|
|
|
|
auto &Devices = FVisualLogger::Get().GetDevices();
|
|
for (auto CurrentDevice : Devices)
|
|
{
|
|
if (CurrentDevice != NULL && CurrentDevice->HasFlags(EVisualLoggerDeviceFlags::StoreLogsLocally))
|
|
{
|
|
TArray<FVisualLogDevice::FVisualLogEntryItem> RecordedLogs;
|
|
CurrentDevice->GetRecordedLogs(RecordedLogs);
|
|
PullDataFromVisualLog(RecordedLogs);
|
|
break;
|
|
}
|
|
|
|
}
|
|
FVisualLogger& VisualLog = FVisualLogger::Get();
|
|
VisualLog.AddDevice(this);
|
|
|
|
// Give window to slate
|
|
if (!LogWindow.IsValid())
|
|
{
|
|
// Make a window
|
|
TSharedRef<SWindow> NewWindow = SNew(SWindow)
|
|
.ClientSize(FVector2D(720,768))
|
|
.Title( NSLOCTEXT("LogVisualizer", "WindowTitle", "Log Visualizer") )
|
|
[
|
|
SNew(SLogVisualizer, this)
|
|
];
|
|
|
|
LogWindow = FSlateApplication::Get().AddWindow(NewWindow);
|
|
}
|
|
|
|
//@TODO fill Logs array with whatever is there in FVisualLog instance
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogLogVisualizer, Warning, TEXT("FLogVisualizer::SummonUI: Not in game thread."));
|
|
}
|
|
}
|
|
|
|
void FLogVisualizer::CloseUI(UWorld* InWorld)
|
|
{
|
|
UE_LOG(LogLogVisualizer, Log, TEXT("Opening LogVisualizer..."));
|
|
|
|
if( IsInGameThread() )
|
|
{
|
|
if (LogWindow.IsValid() && (World.IsValid() == false || World == InWorld))
|
|
{
|
|
DebugActor = NULL;
|
|
|
|
CleanUp();
|
|
FSlateApplication::Get().RequestDestroyWindow(LogWindow.Pin().ToSharedRef());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogLogVisualizer, Warning, TEXT("FLogVisualizer::CloseUI: Not in game thread."));
|
|
}
|
|
}
|
|
|
|
bool FLogVisualizer::IsOpenUI(UWorld* InWorld)
|
|
{
|
|
if (LogWindow.IsValid() && World.IsValid() && World == InWorld)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void FLogVisualizer::CleanUp()
|
|
{
|
|
FVisualLogger& VisualLog = FVisualLogger::Get();
|
|
VisualLog.RemoveDevice(this);
|
|
}
|
|
|
|
class AActor* FLogVisualizer::GetHelperActor(class UWorld* InWorld)
|
|
{
|
|
UWorld* ActorWorld = DebugActor.IsValid() ? DebugActor->GetWorld() : NULL;
|
|
if (DebugActor.IsValid() && ActorWorld == InWorld)
|
|
{
|
|
return DebugActor.Get();
|
|
}
|
|
|
|
for (TActorIterator<ALogVisualizerDebugActor> It(InWorld); It; ++It)
|
|
{
|
|
ALogVisualizerDebugActor* LogVisualizerDebugActor = *It;
|
|
|
|
DebugActor = LogVisualizerDebugActor;
|
|
return LogVisualizerDebugActor;
|
|
}
|
|
|
|
FActorSpawnParameters SpawnInfo;
|
|
SpawnInfo.bNoCollisionFail = true;
|
|
SpawnInfo.Name = *FString::Printf(TEXT("LogVisualizerDebugActor"));
|
|
DebugActor = InWorld->SpawnActor<ALogVisualizerDebugActor>(SpawnInfo);
|
|
|
|
return DebugActor.Get();
|
|
}
|
|
|
|
void FLogVisualizer::PullDataFromVisualLog(const TArray<FVisualLogDevice::FVisualLogEntryItem>& RecordedLogs)
|
|
{
|
|
Logs.Reset();
|
|
HelperMap.Reset();
|
|
|
|
for (auto& CurrentLog : RecordedLogs)
|
|
{
|
|
if (HelperMap.Contains(CurrentLog.OwnerName) == false)
|
|
{
|
|
HelperMap.Add(CurrentLog.OwnerName, MakeShareable(new FActorsVisLog(CurrentLog.OwnerName, NULL)));
|
|
}
|
|
HelperMap[CurrentLog.OwnerName]->Entries.Add(MakeShareable(new FVisualLogEntry(CurrentLog.Entry)));
|
|
}
|
|
|
|
for (auto& CurrentLog : HelperMap)
|
|
{
|
|
Logs.Add(CurrentLog.Value);
|
|
LogAddedEvent.Broadcast();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void FLogVisualizer::OnNewLog(const UObject* Object, TSharedPtr<FActorsVisLog> Log)
|
|
{
|
|
Logs.Add(Log);
|
|
LogAddedEvent.Broadcast();
|
|
}
|
|
|
|
void FLogVisualizer::Serialize(const class UObject* LogOwner, FName OwnerName, const FVisualLogEntry& CurrentLog)
|
|
{
|
|
const bool bContainsLogOwner = HelperMap.Contains(OwnerName);
|
|
if (!bContainsLogOwner)
|
|
{
|
|
HelperMap.Add(OwnerName, MakeShareable(new FActorsVisLog(OwnerName, NULL)));
|
|
}
|
|
HelperMap[OwnerName]->Entries.Add(MakeShareable(new FVisualLogEntry(CurrentLog)));
|
|
|
|
if (!bContainsLogOwner)
|
|
{
|
|
Logs.Add(HelperMap[OwnerName]);
|
|
LogAddedEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
void FLogVisualizer::AddLoadedLog(TSharedPtr<FActorsVisLog> Log)
|
|
{
|
|
for (int32 Index = 0; Index < Logs.Num(); ++Index)
|
|
{
|
|
if (Logs[Index]->Name == Log->Name)
|
|
{
|
|
Logs[Index]->Entries.Append(Log->Entries);
|
|
LogAddedEvent.Broadcast();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (Log.IsValid() && Log->Entries.Num() > 0)
|
|
{
|
|
Logs.Add(Log);
|
|
LogAddedEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
bool FLogVisualizer::IsRecording()
|
|
{
|
|
return FVisualLogger::Get().IsRecording();
|
|
}
|
|
|
|
void FLogVisualizer::SetIsRecording(bool bNewRecording)
|
|
{
|
|
FVisualLogger::Get().SetIsRecording(bNewRecording);
|
|
}
|
|
|
|
int32 FLogVisualizer::GetLogIndexForActor(const AActor* Actor)
|
|
{
|
|
int32 ResultIndex = INDEX_NONE;
|
|
if (!Actor)
|
|
{
|
|
return INDEX_NONE;
|
|
}
|
|
const FString FullName = Actor->GetFullName();
|
|
TSharedPtr<FActorsVisLog>* Log = Logs.GetData();
|
|
for (int32 LogIndex = 0; LogIndex < Logs.Num(); ++LogIndex, ++Log)
|
|
{
|
|
if ((*Log).IsValid() && (*Log)->FullName == FullName)
|
|
{
|
|
ResultIndex = LogIndex;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ResultIndex;
|
|
}
|
|
|
|
#endif //ENABLE_VISUAL_LOG
|