/**
* Scans feature pack folder and verifies that all feature packs therein are parsed successfully.
*
* @param Parameters - Unused for this test
* @return TRUE if the test was successful, FALSE otherwise
*/
bool FFeaturePackValidityTest::RunTest(const FString& Parameters)
{
FString FeaturePackPath = FPaths::FeaturePackDir();
FeaturePackPath += TEXT("*.upack");
int32 FailCount = 0;
IPlatformFile &PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
TArray<FString> FeaturePacks;
IFileManager::Get().FindFiles(FeaturePacks, *FeaturePackPath, true, false );
for (auto FeaturePackFile : FeaturePacks)
{
TUniquePtr<FFeaturePackContentSource> NewContentSource = MakeUnique<FFeaturePackContentSource>(FPaths::FeaturePackDir() + FeaturePackFile, true);
if (NewContentSource->IsDataValid() == false)
{
FailCount++;
for (int32 iError = 0; iError < NewContentSource->ParseErrors.Num() ; iError++)
{
AddError(NewContentSource->ParseErrors[iError]);
}
}
}
return FailCount==0;
}
FBlueprintNativeCodeGenManifest& FBlueprintNativeCodeGenModule::GetManifest(const TCHAR* PlatformName)
{
FString PlatformNameStr(PlatformName);
TUniquePtr<FBlueprintNativeCodeGenManifest>* Result = Manifests.Find(PlatformNameStr);
check(Result->IsValid());
return **Result;
}
FModel* FResourceGroup::LoadModel(const std::string& Filename)
{
FModel* Model = Models.GetResource(Filename);
if (Model == nullptr)
{
TUniquePtr<FZipArchive> Archive = Make_Unique<FZipArchive>(EZipArchiveMode::Read);
if (Archive->OpenFile(Filename))
{
Archive->OpenFirstSubFile();
Model = LoadModel(Filename, Archive.Get());
}
}
return Model;
}
bool FMergeActorsModule::RegisterMergeActorsTool(TUniquePtr<IMergeActorsTool> Tool)
{
if (Tool.Get() != nullptr && !MergeActorsTools.Contains(MoveTemp(Tool)))
{
MergeActorsTools.Add(MoveTemp(Tool));
// If a tool is added while the toolbar widget is active, update it accordingly
TSharedPtr<SMergeActorsToolbar> MergeActorsToolbar = MergeActorsToolbarPtr.Pin();
if (MergeActorsToolbar.IsValid())
{
MergeActorsToolbar->AddTool(Tool.Get());
}
return true;
}
return false;
}
FTexture* FResourceGroup::LoadTexture(const std::string& Filename, bool bIsGammaSpace)
{
FTexture* Texture = Textures.GetResource(Filename);
if (Texture == nullptr)
{
TUniquePtr<FZipArchive> Archive = Make_Unique<FZipArchive>(EZipArchiveMode::Read);
if (Archive->OpenFile(BaseTexturePath + Filename))
{
Archive->OpenFirstSubFile();
Texture = LoadTexture(Filename, Archive.Get(), bIsGammaSpace);
}
else
{
return nullptr;
}
}
return Texture;
}
void FFeaturePackContentSourceProvider::RefreshFeaturePacks()
{
ContentSources.Empty();
IPlatformFile &PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
FFillArrayDirectoryVisitor DirectoryVisitor;
PlatformFile.IterateDirectory( *FeaturePackPath, DirectoryVisitor );
for ( auto FeaturePackFile : DirectoryVisitor.Files )
{
if( FeaturePackFile.EndsWith(TEXT(".upack")) == true)
{
TUniquePtr<FFeaturePackContentSource> NewContentSource = MakeUnique<FFeaturePackContentSource>(FeaturePackFile);
if (NewContentSource->IsDataValid())
{
ContentSources.Add(MakeShareable(NewContentSource.Release()));
}
}
}
ContentSources.Sort(FFeaturePackCompareSortKey());
OnContentSourcesChanged.ExecuteIfBound();
}
/** Comparison function in the event of a tie*/
FORCEINLINE bool CompareNext(const TSharedPtr<FAssetViewItem>& A, const TSharedPtr<FAssetViewItem>& B) const
{
if (NextComparisons.Num() > 0)
{
TUniquePtr<FCompareFAssetItemBase> CompareNext = MoveTemp(NextComparisons[0]);
check(CompareNext);
NextComparisons.RemoveAt(0);
// Move all the remaining comparisons to the next comparitor
CompareNext->SetNextComparisons(GetNextComparisons());
const bool Result = CompareNext->Compare(A, B);
// Move the comparisons back for further ties
SetNextComparisons(CompareNext->GetNextComparisons());
NextComparisons.Insert(MoveTemp(CompareNext), 0);
return Result;
}
return true; // default to true if a tie
}
bool FCompressedFileBuffer::CompressFileToWorkingBuffer(const FPakInputPair& InFile, uint8*& InOutPersistentBuffer, int64& InOutBufferSize, ECompressionFlags CompressionMethod, const int32 CompressionBlockSize)
{
TAutoPtr<FArchive> FileHandle(IFileManager::Get().CreateFileReader(*InFile.Source));
if(!FileHandle.IsValid())
{
TotalCompressedSize = 0;
return false;
}
Reinitialize(FileHandle.GetOwnedPointer(), CompressionMethod, CompressionBlockSize);
const int64 FileSize = OriginalSize;
const int64 PaddedEncryptedFileSize = Align(FileSize,FAES::AESBlockSize);
if(InOutBufferSize < PaddedEncryptedFileSize)
{
InOutPersistentBuffer = (uint8*)FMemory::Realloc(InOutPersistentBuffer,PaddedEncryptedFileSize);
InOutBufferSize = FileSize;
}
// Load to buffer
FileHandle->Serialize(InOutPersistentBuffer,FileSize);
// Build buffers for working
int64 UncompressedSize = FileSize;
int32 CompressionBufferSize = Align(FCompression::CompressMemoryBound(CompressionMethod,CompressionBlockSize),FAES::AESBlockSize);
EnsureBufferSpace(Align(FCompression::CompressMemoryBound(CompressionMethod,FileSize),FAES::AESBlockSize));
TotalCompressedSize = 0;
int64 UncompressedBytes = 0;
int32 CurrentBlock = 0;
while(UncompressedSize)
{
int32 BlockSize = (int32)FMath::Min<int64>(UncompressedSize,CompressionBlockSize);
int32 CompressedBlockSize = CompressionBufferSize;
FileCompressionBlockSize = FMath::Max<uint32>(BlockSize, FileCompressionBlockSize);
EnsureBufferSpace(TotalCompressedSize+CompressedBlockSize);
if(!FCompression::CompressMemory(CompressionMethod,CompressedBuffer.Get()+TotalCompressedSize,CompressedBlockSize,InOutPersistentBuffer+UncompressedBytes,BlockSize))
{
return false;
}
UncompressedSize -= BlockSize;
UncompressedBytes += BlockSize;
CompressedBlocks[CurrentBlock].CompressedStart = TotalCompressedSize;
CompressedBlocks[CurrentBlock].CompressedEnd = TotalCompressedSize+CompressedBlockSize;
++CurrentBlock;
TotalCompressedSize += CompressedBlockSize;
if(InFile.bNeedEncryption)
{
int32 EncryptionBlockPadding = Align(TotalCompressedSize,FAES::AESBlockSize);
for(int64 FillIndex=TotalCompressedSize; FillIndex < EncryptionBlockPadding; ++FillIndex)
{
// Fill the trailing buffer with random bytes from file
CompressedBuffer.Get()[FillIndex] = CompressedBuffer.Get()[rand()%TotalCompressedSize];
}
TotalCompressedSize += EncryptionBlockPadding - TotalCompressedSize;
}
}
return true;
}
void FAssetViewSortManager::SortList(TArray<TSharedPtr<FAssetViewItem>>& AssetItems, const FName& MajorityAssetType) const
{
//double SortListStartTime = FPlatformTime::Seconds();
TArray<TUniquePtr<FCompareFAssetItemBase>> SortMethod;
for (int32 PriorityIdx = 0; PriorityIdx < EColumnSortPriority::Max; PriorityIdx++)
{
const bool bAscending(SortMode[PriorityIdx] == EColumnSortMode::Ascending);
const FName& Tag(SortColumnId[PriorityIdx]);
if (Tag == NAME_None)
{
break;
}
if (Tag == NameColumnId)
{
SortMethod.Add(MakeUnique<FCompareFAssetItemByName>(bAscending, Tag));
}
else if (Tag == ClassColumnId)
{
SortMethod.Add(MakeUnique<FCompareFAssetItemByClass>(bAscending, Tag));
}
else if (Tag == PathColumnId)
{
SortMethod.Add(MakeUnique<FCompareFAssetItemByPath>(bAscending, Tag));
}
else
{
// Since this SortData.Tag is not one of preset columns, sort by asset registry tag
UObject::FAssetRegistryTag::ETagType TagType = UObject::FAssetRegistryTag::TT_Alphabetical;
if (MajorityAssetType != NAME_None)
{
UClass* Class = FindObject<UClass>(ANY_PACKAGE, *MajorityAssetType.ToString());
if (Class)
{
UObject* CDO = Class->GetDefaultObject();
if (CDO)
{
TArray<UObject::FAssetRegistryTag> TagList;
CDO->GetAssetRegistryTags(TagList);
for (auto TagIt = TagList.CreateConstIterator(); TagIt; ++TagIt)
{
if (TagIt->Name == Tag)
{
TagType = TagIt->Type;
break;
}
}
}
}
}
if (TagType == UObject::FAssetRegistryTag::TT_Numerical)
{
// The property is a Num2er, compare using atof
SortMethod.Add(MakeUnique<FCompareFAssetItemByTagNumerical>(bAscending, Tag));
}
else if (TagType == UObject::FAssetRegistryTag::TT_Dimensional)
{
// The property is a series of Num2ers representing dimensions, compare by using atof for each Num2er, delimited by an "x"
SortMethod.Add(MakeUnique<FCompareFAssetItemByTagDimensional>(bAscending, Tag));
}
else
{
// Unknown or alphabetical, sort alphabetically either way
SortMethod.Add(MakeUnique<FCompareFAssetItemByTag>(bAscending, Tag));
}
}
}
// Sort the list...
if (SortMethod.Num() > 0)
{
TUniquePtr<FCompareFAssetItemBase> PrimarySortMethod = MoveTemp(SortMethod[EColumnSortPriority::Primary]);
check(PrimarySortMethod);
SortMethod.RemoveAt(0);
// Move all the comparisons to the primary sort method
PrimarySortMethod->SetNextComparisons(SortMethod);
AssetItems.Sort(*(PrimarySortMethod.Get()));
// Move the comparisons back for ease of cleanup
SortMethod = MoveTemp(PrimarySortMethod->GetNextComparisons());
SortMethod.Insert(MoveTemp(PrimarySortMethod), 0);
}
// Cleanup the methods we no longer need.
for (int32 PriorityIdx = 0; PriorityIdx < SortMethod.Num(); PriorityIdx++)
{
SortMethod[PriorityIdx].Reset();
}
SortMethod.Empty();
//UE_LOG(LogContentBrowser, Warning/*VeryVerbose*/, TEXT("FAssetViewSortManager Sort Time: %0.4f seconds."), FPlatformTime::Seconds() - SortListStartTime);
}
