bool FContentComparisonHelper::CompareClasses(const FString& InBaseClassName, const TArray<FString>& InBaseClassesToIgnore, int32 InRecursionDepth)
{
TMap<FString,TArray<FContentComparisonAssetInfo> > ClassToAssetsMap;
UClass* TheClass = (UClass*)StaticFindObject(UClass::StaticClass(), ANY_PACKAGE, *InBaseClassName, true);
if (TheClass != NULL)
{
TArray<UClass*> IgnoreBaseClasses;
for (int32 IgnoreIdx = 0; IgnoreIdx < InBaseClassesToIgnore.Num(); IgnoreIdx++)
{
UClass* IgnoreClass = (UClass*)StaticFindObject(UClass::StaticClass(), ANY_PACKAGE, *(InBaseClassesToIgnore[IgnoreIdx]), true);
if (IgnoreClass != NULL)
{
IgnoreBaseClasses.Add(IgnoreClass);
}
}
for( TObjectIterator<UClass> It; It; ++It )
{
UClass* TheAssetClass = *It;
if ((TheAssetClass->IsChildOf(TheClass) == true) &&
(TheAssetClass->HasAnyClassFlags(CLASS_Abstract) == false))
{
bool bSkipIt = false;
for (int32 CheckIdx = 0; CheckIdx < IgnoreBaseClasses.Num(); CheckIdx++)
{
UClass* CheckClass = IgnoreBaseClasses[CheckIdx];
if (TheAssetClass->IsChildOf(CheckClass) == true)
{
// UE_LOG(LogEngineUtils, Warning, TEXT("Skipping class derived from other content comparison class..."));
// UE_LOG(LogEngineUtils, Warning, TEXT("\t%s derived from %s"), *TheAssetClass->GetFullName(), *CheckClass->GetFullName());
bSkipIt = true;
}
}
if (bSkipIt == false)
{
TArray<FContentComparisonAssetInfo>* AssetList = ClassToAssetsMap.Find(TheAssetClass->GetFullName());
if (AssetList == NULL)
{
TArray<FContentComparisonAssetInfo> TempAssetList;
ClassToAssetsMap.Add(TheAssetClass->GetFullName(), TempAssetList);
AssetList = ClassToAssetsMap.Find(TheAssetClass->GetFullName());
}
check(AssetList);
// Serialize object with reference collector.
const int32 MaxRecursionDepth = 6;
InRecursionDepth = FMath::Clamp<int32>(InRecursionDepth, 1, MaxRecursionDepth);
TMap<UObject*,bool> RecursivelyGatheredReferences;
RecursiveObjectCollection(TheAssetClass, 0, InRecursionDepth, RecursivelyGatheredReferences);
// Add them to the asset list
for (TMap<UObject*,bool>::TIterator GatheredIt(RecursivelyGatheredReferences); GatheredIt; ++GatheredIt)
{
UObject* Object = GatheredIt.Key();
if (Object)
{
bool bAddIt = true;
if (ReferenceClassesOfInterest.Num() > 0)
{
FString CheckClassName = Object->GetClass()->GetName();
if (ReferenceClassesOfInterest.Find(CheckClassName) == NULL)
{
bAddIt = false;
}
}
if (bAddIt == true)
{
int32 NewIndex = AssetList->AddZeroed();
FContentComparisonAssetInfo& Info = (*AssetList)[NewIndex];
Info.AssetName = Object->GetFullName();
Info.ResourceSize = Object->GetResourceSize(EResourceSizeMode::Inclusive);
}
}
}
}
}
}
}
else
{
UE_LOG(LogEngineUtils, Warning, TEXT("Failed to find class: %s"), *InBaseClassName);
return false;
}
#if 0
// Log them all out
UE_LOG(LogEngineUtils, Log, TEXT("CompareClasses on %s"), *InBaseClassName);
for (TMap<FString,TArray<FContentComparisonAssetInfo>>::TIterator It(ClassToAssetsMap); It; ++It)
{
FString ClassName = It.Key();
TArray<FContentComparisonAssetInfo>& AssetList = It.Value();
UE_LOG(LogEngineUtils, Log, TEXT("\t%s"), *ClassName);
for (int32 AssetIdx = 0; AssetIdx < AssetList.Num(); AssetIdx++)
{
FContentComparisonAssetInfo& Info = AssetList(AssetIdx);
UE_LOG(LogEngineUtils, Log, TEXT("\t\t%s,%f"), *(Info.AssetName), Info.ResourceSize/1024.0f);
}
}
#endif
#if ALLOW_DEBUG_FILES
// Write out a CSV file
FString CurrentTime = FDateTime::Now().ToString();
FString Platform(FPlatformProperties::PlatformName());
FString BaseCSVName = (
FString(TEXT("ContentComparison/")) +
FString::Printf(TEXT("ContentCompare-%s/"), *GEngineVersion.ToString()) +
FString::Printf(TEXT("%s"), *InBaseClassName)
);
// Handle file name length on consoles...
FString EditedBaseClassName = InBaseClassName;
FString TimeString = *FDateTime::Now().ToString();
FString CheckLenName = FString::Printf(TEXT("%s-%s.csv"),*InBaseClassName,*TimeString);
if (CheckLenName.Len() > PLATFORM_MAX_FILEPATH_LENGTH)
{
while (CheckLenName.Len() > PLATFORM_MAX_FILEPATH_LENGTH)
{
EditedBaseClassName = EditedBaseClassName.Right(EditedBaseClassName.Len() - 1);
CheckLenName = FString::Printf(TEXT("%s-%s.csv"),*EditedBaseClassName,*TimeString);
}
BaseCSVName = (
FString(TEXT("ContentComparison/")) +
FString::Printf(TEXT("ContentCompare-%s/"), *GEngineVersion.ToString()) +
FString::Printf(TEXT("%s"), *EditedBaseClassName)
);
}
FDiagnosticTableViewer* AssetTable = new FDiagnosticTableViewer(
*FDiagnosticTableViewer::GetUniqueTemporaryFilePath(*BaseCSVName), true);
if ((AssetTable != NULL) && (AssetTable->OutputStreamIsValid() == true))
{
// Fill in the header row
AssetTable->AddColumn(TEXT("Class"));
AssetTable->AddColumn(TEXT("Asset"));
AssetTable->AddColumn(TEXT("ResourceSize(kB)"));
AssetTable->CycleRow();
// Fill it in
for (TMap<FString,TArray<FContentComparisonAssetInfo> >::TIterator It(ClassToAssetsMap); It; ++It)
{
FString ClassName = It.Key();
TArray<FContentComparisonAssetInfo>& AssetList = It.Value();
AssetTable->AddColumn(*ClassName);
AssetTable->CycleRow();
for (int32 AssetIdx = 0; AssetIdx < AssetList.Num(); AssetIdx++)
{
FContentComparisonAssetInfo& Info = AssetList[AssetIdx];
AssetTable->AddColumn(TEXT(""));
AssetTable->AddColumn(*(Info.AssetName));
AssetTable->AddColumn(TEXT("%f"), Info.ResourceSize/1024.0f);
AssetTable->CycleRow();
}
}
}
else if (AssetTable != NULL)
{
// Created the class, but it failed to open the output stream.
UE_LOG(LogEngineUtils, Warning, TEXT("Failed to open output stream in asset table!"));
}
if (AssetTable != NULL)
{
// Close it and kill it
AssetTable->Close();
delete AssetTable;
}
#endif
return true;
}
/** Add a new statistic to the internal map (or update an existing one) from the supplied component */
UPrimitiveStats* Add(UPrimitiveComponent* InPrimitiveComponent, EPrimitiveObjectSets InObjectSet)
{
// Objects in transient package or transient objects are not part of level.
if( InPrimitiveComponent->GetOutermost() == GetTransientPackage() || InPrimitiveComponent->HasAnyFlags( RF_Transient ) )
{
return NULL;
}
// Owned by a default object? Not part of a level either.
if(InPrimitiveComponent->GetOuter() && InPrimitiveComponent->GetOuter()->IsDefaultSubobject() )
{
return NULL;
}
UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(InPrimitiveComponent);
UModelComponent* ModelComponent = Cast<UModelComponent>(InPrimitiveComponent);
USkeletalMeshComponent* SkeletalMeshComponent = Cast<USkeletalMeshComponent>(InPrimitiveComponent);
ULandscapeComponent* LandscapeComponent = Cast<ULandscapeComponent>(InPrimitiveComponent);
UObject* Resource = NULL;
AActor* ActorOuter = Cast<AActor>(InPrimitiveComponent->GetOuter());
int32 VertexColorMem = 0;
int32 InstVertexColorMem = 0;
// Calculate number of direct and other lights relevant to this component.
int32 LightsLMCount = 0;
int32 LightsOtherCount = 0;
bool bUsesOnlyUnlitMaterials = InPrimitiveComponent->UsesOnlyUnlitMaterials();
// The static mesh is a static mesh component's resource.
if( StaticMeshComponent )
{
UStaticMesh* Mesh = StaticMeshComponent->StaticMesh;
Resource = Mesh;
// Calculate vertex color memory on the actual mesh.
if( Mesh && Mesh->RenderData )
{
// Accumulate memory for each LOD
for( int32 LODIndex = 0; LODIndex < Mesh->RenderData->LODResources.Num(); ++LODIndex )
{
VertexColorMem += Mesh->RenderData->LODResources[LODIndex].ColorVertexBuffer.GetAllocatedSize();
}
}
// Calculate instanced vertex color memory used on the component.
for( int32 LODIndex = 0; LODIndex < StaticMeshComponent->LODData.Num(); ++LODIndex )
{
// Accumulate memory for each LOD
const FStaticMeshComponentLODInfo& LODInfo = StaticMeshComponent->LODData[ LODIndex ];
if( LODInfo.OverrideVertexColors )
{
InstVertexColorMem += LODInfo.OverrideVertexColors->GetAllocatedSize();
}
}
// Calculate the number of lightmap and shadow map lights
if( !bUsesOnlyUnlitMaterials )
{
if( StaticMeshComponent->LODData.Num() > 0 )
{
FStaticMeshComponentLODInfo& ComponentLODInfo = StaticMeshComponent->LODData[0];
if( ComponentLODInfo.LightMap )
{
LightsLMCount = ComponentLODInfo.LightMap->LightGuids.Num();
}
}
}
}
// A model component is its own resource.
else if( ModelComponent )
{
// Make sure model component is referenced by level.
ULevel* Level = CastChecked<ULevel>(ModelComponent->GetOuter());
if( Level->ModelComponents.Find( ModelComponent ) != INDEX_NONE )
{
Resource = ModelComponent->GetModel();
// Calculate the number of lightmap and shadow map lights
if( !bUsesOnlyUnlitMaterials )
{
const TIndirectArray<FModelElement> Elements = ModelComponent->GetElements();
if( Elements.Num() > 0 )
{
if( Elements[0].LightMap )
{
LightsLMCount = Elements[0].LightMap->LightGuids.Num();
}
}
}
}
}
// The skeletal mesh of a skeletal mesh component is its resource.
else if( SkeletalMeshComponent )
{
USkeletalMesh* Mesh = SkeletalMeshComponent->SkeletalMesh;
Resource = Mesh;
// Calculate vertex color usage for skeletal meshes
if( Mesh )
{
FSkeletalMeshResource* SkelMeshResource = Mesh->GetResourceForRendering();
for( int32 LODIndex = 0; LODIndex < SkelMeshResource->LODModels.Num(); ++LODIndex )
{
const FStaticLODModel& LODModel = SkelMeshResource->LODModels[ LODIndex ];
VertexColorMem += LODModel.ColorVertexBuffer.GetVertexDataSize();
}
}
}
// The landscape of a landscape component is its resource.
else if (LandscapeComponent)
{
Resource = LandscapeComponent->GetLandscapeProxy();
if (LandscapeComponent->LightMap)
{
LightsLMCount = LandscapeComponent->LightMap->LightGuids.Num();
}
}
UWorld* World = InPrimitiveComponent->GetWorld();
// check(World); // @todo: re-instate this check once the GWorld migration has completed
/// If we should skip the actor. Skip if the actor has no outer or if we are only showing selected actors and the actor isn't selected
const bool bShouldSkip = World == NULL || ActorOuter == NULL || (ActorOuter != NULL && InObjectSet == PrimitiveObjectSets_SelectedObjects && ActorOuter->IsSelected() == false );
// Dont' care about components without a resource.
if( Resource
// Require actor association for selection and to disregard mesh emitter components. The exception being model components.
&& (!bShouldSkip || (ModelComponent && InObjectSet != PrimitiveObjectSets_SelectedObjects ) )
// Only list primitives in visible levels
&& IsInVisibleLevel( InPrimitiveComponent, World )
// Don't list pending kill components.
&& !InPrimitiveComponent->IsPendingKill() )
{
// Retrieve relevant lights.
TArray<const ULightComponent*> RelevantLights;
World->Scene->GetRelevantLights( InPrimitiveComponent, &RelevantLights );
// Only look for relevant lights if we aren't unlit.
if( !bUsesOnlyUnlitMaterials )
{
// Lightmap and shadow map lights are calculated above, per component type, infer the "other" light count here
LightsOtherCount = RelevantLights.Num() >= LightsLMCount ? RelevantLights.Num() - LightsLMCount : 0;
}
// Figure out memory used by light and shadow maps and light/ shadow map resolution.
int32 LightMapWidth = 0;
int32 LightMapHeight = 0;
InPrimitiveComponent->GetLightMapResolution( LightMapWidth, LightMapHeight );
int32 LMSMResolution = FMath::Sqrt( LightMapHeight * LightMapWidth );
int32 LightMapData = 0;
int32 LegacyShadowMapData = 0;
InPrimitiveComponent->GetLightAndShadowMapMemoryUsage( LightMapData, LegacyShadowMapData );
// Check whether we already have an entry for the associated static mesh.
UPrimitiveStats** StatsEntryPtr = ResourceToStatsMap.Find( Resource );
if( StatsEntryPtr )
{
check(*StatsEntryPtr);
UPrimitiveStats* StatsEntry = *StatsEntryPtr;
// We do. Update existing entry.
StatsEntry->Count++;
StatsEntry->Actors.AddUnique(ActorOuter);
StatsEntry->RadiusMin = FMath::Min( StatsEntry->RadiusMin, InPrimitiveComponent->Bounds.SphereRadius );
StatsEntry->RadiusMax = FMath::Max( StatsEntry->RadiusMax, InPrimitiveComponent->Bounds.SphereRadius );
StatsEntry->RadiusAvg += InPrimitiveComponent->Bounds.SphereRadius;
StatsEntry->LightsLM += LightsLMCount;
StatsEntry->LightsOther += LightsOtherCount;
StatsEntry->LightMapData += (float)LightMapData / 1024.0f;
StatsEntry->LMSMResolution += LMSMResolution;
StatsEntry->UpdateNames();
if ( !ModelComponent && !LandscapeComponent )
{
// Count instanced sections
StatsEntry->InstSections += StatsEntry->Sections;
StatsEntry->InstTriangles += StatsEntry->Triangles;
}
// ... in the case of a model component (aka BSP).
if( ModelComponent )
{
// If Count represents the Model itself, we do NOT want to increment it now.
StatsEntry->Count--;
for (const auto& Element : ModelComponent->GetElements())
{
StatsEntry->Triangles += Element.NumTriangles;
StatsEntry->Sections++;
}
StatsEntry->InstSections = StatsEntry->Sections;
StatsEntry->InstTriangles = StatsEntry->Triangles;
}
else if( StaticMeshComponent )
{
// This stat is used by multiple components so accumulate instanced vertex color memory.
StatsEntry->InstVertexColorMem += (float)InstVertexColorMem / 1024.0f;
}
else if (LandscapeComponent)
{
// If Count represents the Landscape itself, we do NOT want to increment it now.
StatsEntry->Count--;
}
}
else
{
// We don't. Create new base entry.
UPrimitiveStats* NewStatsEntry = NewObject<UPrimitiveStats>();
NewStatsEntry->AddToRoot();
NewStatsEntry->Object = Resource;
NewStatsEntry->Actors.AddUnique(ActorOuter);
NewStatsEntry->Count = 1;
NewStatsEntry->Triangles = 0;
NewStatsEntry->InstTriangles = 0;
NewStatsEntry->ResourceSize = (float)(FArchiveCountMem(Resource).GetNum() + Resource->GetResourceSize(EResourceSizeMode::Exclusive)) / 1024.0f;
NewStatsEntry->Sections = 0;
NewStatsEntry->InstSections = 0;
NewStatsEntry->RadiusMin = InPrimitiveComponent->Bounds.SphereRadius;
NewStatsEntry->RadiusAvg = InPrimitiveComponent->Bounds.SphereRadius;
NewStatsEntry->RadiusMax = InPrimitiveComponent->Bounds.SphereRadius;
NewStatsEntry->LightsLM = LightsLMCount;
NewStatsEntry->LightsOther = (float)LightsOtherCount;
NewStatsEntry->LightMapData = (float)LightMapData / 1024.0f;
NewStatsEntry->LMSMResolution = LMSMResolution;
NewStatsEntry->VertexColorMem = (float)VertexColorMem / 1024.0f;
NewStatsEntry->InstVertexColorMem = (float)InstVertexColorMem / 1024.0f;
NewStatsEntry->UpdateNames();
// Fix up triangle and section count...
// ... in the case of a static mesh component.
if( StaticMeshComponent )
{
UStaticMesh* StaticMesh = StaticMeshComponent->StaticMesh;
if( StaticMesh && StaticMesh->RenderData )
{
for( int32 SectionIndex=0; SectionIndex<StaticMesh->RenderData->LODResources[0].Sections.Num(); SectionIndex++ )
{
const FStaticMeshSection& StaticMeshSection = StaticMesh->RenderData->LODResources[0].Sections[SectionIndex];
NewStatsEntry->Triangles += StaticMeshSection.NumTriangles;
NewStatsEntry->Sections++;
}
}
}
// ... in the case of a model component (aka BSP).
else if( ModelComponent )
{
TIndirectArray<FModelElement> Elements = ModelComponent->GetElements();
for( int32 ElementIndex=0; ElementIndex<Elements.Num(); ElementIndex++ )
{
const FModelElement& Element = Elements[ElementIndex];
NewStatsEntry->Triangles += Element.NumTriangles;
NewStatsEntry->Sections++;
}
}
// ... in the case of skeletal mesh component.
else if( SkeletalMeshComponent )
{
USkeletalMesh* SkeletalMesh = SkeletalMeshComponent->SkeletalMesh;
if( SkeletalMesh )
{
FSkeletalMeshResource* SkelMeshResource = SkeletalMesh->GetResourceForRendering();
if (SkelMeshResource->LODModels.Num())
{
const FStaticLODModel& BaseLOD = SkelMeshResource->LODModels[0];
for( int32 SectionIndex=0; SectionIndex<BaseLOD.Sections.Num(); SectionIndex++ )
{
const FSkelMeshSection& Section = BaseLOD.Sections[SectionIndex];
NewStatsEntry->Triangles += Section.NumTriangles;
NewStatsEntry->Sections++;
}
}
}
}
else if (LandscapeComponent)
{
TSet<UTexture2D*> UniqueTextures;
for (auto ItComponents = LandscapeComponent->GetLandscapeProxy()->LandscapeComponents.CreateConstIterator(); ItComponents; ++ItComponents)
{
const ULandscapeComponent* CurrentComponent = *ItComponents;
// count triangles and sections in the landscape
NewStatsEntry->Triangles += FMath::Square(CurrentComponent->ComponentSizeQuads) * 2;
NewStatsEntry->Sections += FMath::Square(CurrentComponent->NumSubsections);
// count resource usage of landscape
bool bNotUnique = false;
UniqueTextures.Add(CurrentComponent->HeightmapTexture, &bNotUnique);
if (!bNotUnique)
{
NewStatsEntry->ResourceSize += CurrentComponent->HeightmapTexture->GetResourceSize(EResourceSizeMode::Exclusive);
}
if (CurrentComponent->XYOffsetmapTexture)
{
UniqueTextures.Add(CurrentComponent->XYOffsetmapTexture, &bNotUnique);
if (!bNotUnique)
{
NewStatsEntry->ResourceSize += CurrentComponent->XYOffsetmapTexture->GetResourceSize(EResourceSizeMode::Exclusive);
}
}
for (auto ItWeightmaps = CurrentComponent->WeightmapTextures.CreateConstIterator(); ItWeightmaps; ++ItWeightmaps)
{
UniqueTextures.Add((*ItWeightmaps), &bNotUnique);
if (!bNotUnique)
{
NewStatsEntry->ResourceSize += (*ItWeightmaps)->GetResourceSize(EResourceSizeMode::Exclusive);
}
}
}
}
NewStatsEntry->InstTriangles = NewStatsEntry->Triangles;
NewStatsEntry->InstSections = NewStatsEntry->Sections;
// Add to map.
ResourceToStatsMap.Add( Resource, NewStatsEntry );
return NewStatsEntry;
}
}
return NULL;
}
void SSizeMap::GatherDependenciesRecursively( FAssetRegistryModule& AssetRegistryModule, TSharedPtr<FAssetThumbnailPool>& InAssetThumbnailPool, TMap<FName, TSharedPtr<FTreeMapNodeData>>& VisitedAssetPackageNames, const TArray<FName>& AssetPackageNames, const TSharedPtr<FTreeMapNodeData>& Node, TSharedPtr<FTreeMapNodeData>& SharedRootNode, int32& NumAssetsWhichFailedToLoad )
{
for( const FName AssetPackageName : AssetPackageNames )
{
// Have we already added this asset to the tree? If so, we'll either move it to a "shared" group or (if it's referenced again by the same
// root-level asset) ignore it
if( VisitedAssetPackageNames.Contains( AssetPackageName ) )
{
// OK, we've determined that this asset has already been referenced by something else in our tree. We'll move it to a "shared" group
// so all of the assets that are referenced in multiple places can be seen together.
TSharedPtr<FTreeMapNodeData> ExistingNode = VisitedAssetPackageNames[ AssetPackageName ];
// Is the existing node not already under the "shared" group? Note that it might still be (indirectly) under
// the "shared" group, in which case we'll still want to move it up to the root since we've figured out that it is
// actually shared between multiple assets which themselves may be shared
if( ExistingNode->Parent != SharedRootNode.Get() )
{
// Don't bother moving any of the assets at the root level into a "shared" bucket. We're only trying to best
// represent the memory used when all of the root-level assets have become loaded. It's OK if root-level assets
// are referenced by other assets in the set -- we don't need to indicate they are shared explicitly
FTreeMapNodeData* ExistingNodeParent = ExistingNode->Parent;
check( ExistingNodeParent != nullptr );
const bool bExistingNodeIsAtRootLevel = ExistingNodeParent->Parent == nullptr || RootAssetPackageNames.Contains( AssetPackageName );
if( !bExistingNodeIsAtRootLevel )
{
// OK, the current asset (AssetPackageName) is definitely not a root level asset, but its already in the tree
// somewhere as a non-shared, non-root level asset. We need to make sure that this Node's reference is not from the
// same root-level asset as the ExistingNodeInTree. Otherwise, there's no need to move it to a 'shared' group.
FTreeMapNodeData* MyParentNode = Node.Get();
check( MyParentNode != nullptr );
FTreeMapNodeData* MyRootLevelAssetNode = MyParentNode;
while( MyRootLevelAssetNode->Parent != nullptr && MyRootLevelAssetNode->Parent->Parent != nullptr )
{
MyRootLevelAssetNode = MyRootLevelAssetNode->Parent;
}
if( MyRootLevelAssetNode->Parent == nullptr )
{
// No root asset (Node must be a root level asset itself!)
MyRootLevelAssetNode = nullptr;
}
// Find the existing node's root level asset node
FTreeMapNodeData* ExistingNodeRootLevelAssetNode = ExistingNodeParent;
while( ExistingNodeRootLevelAssetNode->Parent->Parent != nullptr )
{
ExistingNodeRootLevelAssetNode = ExistingNodeRootLevelAssetNode->Parent;
}
// If we're being referenced by another node within the same asset, no need to move it to a 'shared' group.
if( MyRootLevelAssetNode != ExistingNodeRootLevelAssetNode )
{
// This asset was already referenced by something else (or was in our top level list of assets to display sizes for)
if( !SharedRootNode.IsValid() )
{
// Find the root-most tree node
FTreeMapNodeData* RootNode = MyParentNode;
while( RootNode->Parent != nullptr )
{
RootNode = RootNode->Parent;
}
SharedRootNode = MakeShareable( new FTreeMapNodeData() );
RootNode->Children.Add( SharedRootNode );
SharedRootNode->Parent = RootNode; // Keep back-pointer to parent node
}
// Reparent the node that we've now determined to be shared
ExistingNode->Parent->Children.Remove( ExistingNode );
SharedRootNode->Children.Add( ExistingNode );
ExistingNode->Parent = SharedRootNode.Get();
}
}
}
}
else
{
// This asset is new to us so far! Let's add it to the tree. Later as we descend through references, we might find that the
// asset is referenced by something else as well, in which case we'll pull it out and move it to a "shared" top-level box
// Don't bother showing code references
const FString AssetPackageNameString = AssetPackageName.ToString();
if( !AssetPackageNameString.StartsWith( TEXT( "/Script/" ) ) )
{
FTreeMapNodeDataRef ChildTreeMapNode = MakeShareable( new FTreeMapNodeData() );
Node->Children.Add( ChildTreeMapNode );
ChildTreeMapNode->Parent = Node.Get(); // Keep back-pointer to parent node
VisitedAssetPackageNames.Add( AssetPackageName, ChildTreeMapNode );
FNodeSizeMapData& NodeSizeMapData = NodeSizeMapDataMap.Add( ChildTreeMapNode );
// Set some defaults for this node. These will be used if we can't actually locate the asset.
// @todo sizemap urgent: We need a better indication in the UI when there are one or more missing assets. Because missing assets have a size
// of zero, they are nearly impossible to zoom into. At the least, we should have some Output Log spew when assets cannot be loaded
NodeSizeMapData.AssetData.AssetName = AssetPackageName;
NodeSizeMapData.AssetData.AssetClass = FName( *LOCTEXT( "MissingAsset", "MISSING!" ).ToString() );
NodeSizeMapData.AssetSize = 0;
NodeSizeMapData.bHasKnownSize = false;
// Find the asset using the asset registry
// @todo sizemap: Asset registry-based reference gathering is faster but possibly not as exhaustive (no PostLoad created references, etc.) Maybe should be optional?
// @todo sizemap: With AR-based reference gathering, sometimes the size map is missing root level dependencies until you reopen it a few times (Buggy BP)
// @todo sizemap: With AR-based reference gathering, reference changes at editor-time do not appear in the Size Map until you restart
// @todo sizemap: With AR-based reference gathering, opening the size map for all engine content caused the window to not respond until a restart
// @todo sizemap: We don't really need the asset registry given we need to load the objects to figure out their size, unless we make that AR-searchable.
// ---> This would allow us to not have to wait for AR initialization. But if we made size AR-searchable, we could run very quickly for large data sets!
const bool bUseAssetRegistryForDependencies = false;
const FString AssetPathString = AssetPackageNameString + TEXT(".") + FPackageName::GetLongPackageAssetName( AssetPackageNameString );
const FAssetData FoundAssetData = AssetRegistryModule.Get().GetAssetByObjectPath( FName( *AssetPathString ) );
if( FoundAssetData.IsValid() )
{
NodeSizeMapData.AssetData = FoundAssetData;
// Now actually load up the asset. We need it in memory in order to accurately determine its size.
// @todo sizemap: We could async load these packages to make the editor experience a bit nicer (smoother progress)
UObject* Asset = StaticLoadObject( UObject::StaticClass(), nullptr, *AssetPathString );
if( Asset != nullptr )
{
TArray<FName> ReferencedAssetPackageNames;
if( bUseAssetRegistryForDependencies )
{
AssetRegistryModule.Get().GetDependencies( AssetPackageName, ReferencedAssetPackageNames );
}
else
{
SizeMapInternals::FAssetReferenceFinder References( Asset );
for( UObject* Object : References.GetReferencedAssets() )
{
ReferencedAssetPackageNames.Add( FName( *Object->GetOutermost()->GetPathName() ) );
}
}
// For textures, make sure we're getting the worst case size, not the size of the currently loaded set of mips
// @todo sizemap: We should instead have a special EResourceSizeMode that asks for the worst case size. Some assets (like UTextureCube) currently always report resident mip size, even when asked for inclusive size
if( Asset->IsA( UTexture2D::StaticClass() ) )
{
NodeSizeMapData.AssetSize = Asset->GetResourceSize( EResourceSizeMode::Inclusive );
}
else
{
NodeSizeMapData.AssetSize = Asset->GetResourceSize( EResourceSizeMode::Exclusive );
}
NodeSizeMapData.bHasKnownSize = NodeSizeMapData.AssetSize != UObject::RESOURCE_SIZE_NONE && NodeSizeMapData.AssetSize != 0;
if( !NodeSizeMapData.bHasKnownSize )
{
// Asset has no meaningful size
NodeSizeMapData.AssetSize = 0;
// @todo sizemap urgent: Try to serialize to figure out how big it is (not into sub-assets though!)
// FObjectMemoryAnalyzer ObjectMemoryAnalyzer( Asset );
}
// Now visit all of the assets that we are referencing
GatherDependenciesRecursively( AssetRegistryModule, InAssetThumbnailPool, VisitedAssetPackageNames, ReferencedAssetPackageNames, ChildTreeMapNode, SharedRootNode, NumAssetsWhichFailedToLoad );
}
else
{
++NumAssetsWhichFailedToLoad;
}
}
else
{
++NumAssetsWhichFailedToLoad;
}
}
}
}
}
