516 lines
24 KiB
C++
516 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "Subsystems/CollectionManagerScriptingSubsystem.h"
|
|
|
|
#include "AssetRegistry/AssetData.h"
|
|
#include "AssetRegistry/AssetRegistryModule.h"
|
|
#include "CollectionManagerModule.h"
|
|
#include "ICollectionContainer.h"
|
|
#include "ICollectionManager.h"
|
|
#include "ICollectionSource.h"
|
|
|
|
#include UE_INLINE_GENERATED_CPP_BY_NAME(CollectionManagerScriptingSubsystem)
|
|
|
|
DEFINE_LOG_CATEGORY_STATIC(LogCollectionManagerScripting, Log, All);
|
|
|
|
#define LOCTEXT_NAMESPACE "CollectionManagerScriptingSubsystem"
|
|
|
|
namespace CollectionManagerScriptingSubsystemUtil
|
|
{
|
|
|
|
void LogLastCollectionManagerError(const FText& Error)
|
|
{
|
|
UE_LOG(LogCollectionManagerScripting, Warning, TEXT("Collection manager error: %s"), *Error.ToString());
|
|
}
|
|
|
|
FString ECollectionScriptingShareType_To_String(const ECollectionScriptingShareType ShareType)
|
|
{
|
|
static const UEnum* Enum = FindObject<UEnum>(nullptr, TEXT("/Script/CollectionManager.ECollectionScriptingShareType"), true);
|
|
if (Enum)
|
|
{
|
|
return Enum->GetDisplayNameTextByValue((uint64)ShareType).ToString();
|
|
}
|
|
else
|
|
{
|
|
return {};
|
|
}
|
|
}
|
|
|
|
ECollectionShareType::Type ECollectionScriptingShareType_To_ECollectionShareType(const ECollectionScriptingShareType ShareType)
|
|
{
|
|
static_assert((int32)ECollectionShareType::CST_Local == (int32)ECollectionScriptingShareType::Local + 1, "ECollectionShareType::CST_Local is expected to be ECollectionScriptingShareType::Local + 1");
|
|
static_assert((int32)ECollectionShareType::CST_Private == (int32)ECollectionScriptingShareType::Private + 1, "ECollectionShareType::CST_Private is expected to be ECollectionScriptingShareType::Private + 1");
|
|
static_assert((int32)ECollectionShareType::CST_Shared == (int32)ECollectionScriptingShareType::Shared + 1, "ECollectionShareType::CST_Shared is expected to be ECollectionScriptingShareType::Shared + 1");
|
|
|
|
return (ECollectionShareType::Type)((int32)ShareType + 1);
|
|
}
|
|
|
|
ECollectionScriptingShareType ECollectionShareType_To_ECollectionScriptingShareType(const ECollectionShareType::Type ShareType)
|
|
{
|
|
static_assert((int32)ECollectionShareType::CST_Local == (int32)ECollectionScriptingShareType::Local + 1, "ECollectionShareType::CST_Local is expected to be ECollectionScriptingShareType::Local + 1");
|
|
static_assert((int32)ECollectionShareType::CST_Private == (int32)ECollectionScriptingShareType::Private + 1, "ECollectionShareType::CST_Private is expected to be ECollectionScriptingShareType::Private + 1");
|
|
static_assert((int32)ECollectionShareType::CST_Shared == (int32)ECollectionScriptingShareType::Shared + 1, "ECollectionShareType::CST_Shared is expected to be ECollectionScriptingShareType::Shared + 1");
|
|
|
|
return (ECollectionScriptingShareType)((int32)ShareType - 1);
|
|
}
|
|
|
|
struct FConstants
|
|
{
|
|
static const FConstants& Get()
|
|
{
|
|
static FConstants Instance;
|
|
return Instance;
|
|
}
|
|
|
|
const FText ContainerNotFound;
|
|
const FText CollectionNotFound;
|
|
const FText CollectionExistsInContainer;
|
|
const FText ContainerMismatch;
|
|
const FText FailedToGetAsset;
|
|
|
|
private:
|
|
FConstants() :
|
|
ContainerNotFound(LOCTEXT("ContainerNotFound", "No container with the name '{0}' could be found.")),
|
|
CollectionNotFound(LOCTEXT("CollectionNotFound", "No collection with the name '{0}' and share type '{1}' was found in container with name '{2}'")),
|
|
CollectionExistsInContainer(LOCTEXT("CollectionExistsInContainer", "Container '{0}' already has a collection named '{1}' with share type '{2}'.")),
|
|
ContainerMismatch(LOCTEXT("ContainerMismatch", "Collections must be in the same container to reparent. Found target collection in container '{0}' and new parent collection in container '{1}'.")),
|
|
FailedToGetAsset(LOCTEXT("FailedToGetAsset", "Failed to get Asset '{0}' from Collection '{1}'. Could not get the asset's Object Path."))
|
|
{}
|
|
};
|
|
|
|
} // namespace CollectionManagerScriptingSubsystemUtil
|
|
|
|
TArray<FCollectionScriptingContainerSource> UCollectionManagerScriptingSubsystem::GetCollectionContainers()
|
|
{
|
|
TArray<TSharedPtr<ICollectionContainer>> CollectionContainers;
|
|
FCollectionManagerModule::GetModule().Get().GetCollectionContainers(CollectionContainers);
|
|
|
|
TArray<FCollectionScriptingContainerSource> ContainerNames;
|
|
ContainerNames.Reserve(CollectionContainers.Num());
|
|
Algo::Transform(CollectionContainers, ContainerNames, [](const TSharedPtr<ICollectionContainer>& CollectionContainer)
|
|
{
|
|
return FCollectionScriptingContainerSource {
|
|
.Name = CollectionContainer->GetCollectionSource()->GetName(),
|
|
.Title = CollectionContainer->GetCollectionSource()->GetTitle()
|
|
};
|
|
}
|
|
);
|
|
|
|
return ContainerNames;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::CreateCollection(const FCollectionScriptingContainerSource Container, const FName Collection, const ECollectionScriptingShareType ShareType, FCollectionScriptingRef& OutNewCollection)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Container.Name);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, FText::FromName(Container.Name)));
|
|
return false;
|
|
}
|
|
|
|
const ECollectionShareType::Type CastShareType = CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(ShareType);
|
|
if (CollectionContainer->CollectionExists(Collection, CastShareType))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().CollectionExistsInContainer, { CollectionContainer->GetCollectionSource()->GetTitle(), FText::FromName(Collection), CastShareType }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->IsValidCollectionName(Collection.ToString(), ECollectionShareType::CST_All, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
if (!CollectionContainer->CreateCollection(Collection, CastShareType, ECollectionStorageMode::Static, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
OutNewCollection.Name = Collection;
|
|
OutNewCollection.ShareType = ShareType;
|
|
OutNewCollection.Container = CollectionContainer->GetCollectionSource()->GetName();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::CreateOrEmptyCollection(const FCollectionScriptingContainerSource Container, const FName Collection, const ECollectionScriptingShareType ShareType, FCollectionScriptingRef& OutNewOrEmptyCollection)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Container.Name);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, FText::FromName(Container.Name)));
|
|
return false;
|
|
}
|
|
|
|
const ECollectionShareType::Type CastShareType = CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(ShareType);
|
|
if (CollectionContainer->CollectionExists(Collection, CastShareType))
|
|
{
|
|
FText Error;
|
|
if (!CollectionContainer->EmptyCollection(Collection, CastShareType, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FText Error;
|
|
if (!CollectionContainer->IsValidCollectionName(Collection.ToString(), ECollectionShareType::CST_All, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
if (!CollectionContainer->CreateCollection(Collection, CastShareType, ECollectionStorageMode::Static, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
OutNewOrEmptyCollection.Name = Collection;
|
|
OutNewOrEmptyCollection.ShareType = ShareType;
|
|
OutNewOrEmptyCollection.Container = CollectionContainer->GetCollectionSource()->GetName();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::GetCollections(const FCollectionScriptingContainerSource Container, TArray<FCollectionScriptingRef>& OutCollections)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Container.Name);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Container.Name) }));
|
|
return false;
|
|
}
|
|
|
|
TArray<FCollectionNameType> Collections;
|
|
CollectionContainer->GetCollections(Collections);
|
|
|
|
OutCollections.Reserve(Collections.Num());
|
|
Algo::Transform(Collections, OutCollections, [ContainerName = CollectionContainer->GetCollectionSource()->GetName()](const FCollectionNameType& CollectionName)
|
|
{
|
|
return FCollectionScriptingRef {
|
|
.Container = ContainerName,
|
|
.Name = CollectionName.Name,
|
|
.ShareType = CollectionManagerScriptingSubsystemUtil::ECollectionShareType_To_ECollectionScriptingShareType(CollectionName.Type)
|
|
};
|
|
});
|
|
|
|
return OutCollections.Num() > 0;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::DestroyCollection(const FCollectionScriptingRef& Collection)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->DestroyCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType), &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RenameCollection(const FCollectionScriptingRef& Collection, const FName NewName, const ECollectionScriptingShareType NewShareType)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->IsValidCollectionName(NewName.ToString(), ECollectionShareType::CST_All, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
if (!CollectionContainer->RenameCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType),
|
|
NewName, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(NewShareType), &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::ReparentCollection(const FCollectionScriptingRef& Collection, const FCollectionScriptingRef NewParentCollection)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
// If the intention is to reparent to a different collection, make sure its in the same container.
|
|
if (!NewParentCollection.Name.IsNone() && Collection.Container != NewParentCollection.Container)
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerMismatch, { FText::FromName(Collection.Container), FText::FromName(NewParentCollection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->ReparentCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType),
|
|
NewParentCollection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(NewParentCollection.ShareType), &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::EmptyCollection(const FCollectionScriptingRef& Collection)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->EmptyCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType), &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::AddAssetToCollection(const FCollectionScriptingRef& Collection, const FSoftObjectPath& AssetPath)
|
|
{
|
|
return AddAssetsToCollection(Collection, TArray<FSoftObjectPath>({ AssetPath }));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::AddAssetDataToCollection(const FCollectionScriptingRef& Collection, const FAssetData& AssetData)
|
|
{
|
|
return AddAssetsToCollection(Collection, TArray<FSoftObjectPath>({ AssetData.GetSoftObjectPath() }));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::AddAssetPtrToCollection(const FCollectionScriptingRef& Collection, const UObject* AssetPtr)
|
|
{
|
|
return AddAssetsToCollection(Collection, TArray<FSoftObjectPath>({ FSoftObjectPath(AssetPtr) }));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::AddAssetsToCollection(const FCollectionScriptingRef& Collection, const TArray<FSoftObjectPath>& AssetPaths)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->AddToCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType), AssetPaths, nullptr, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::AddAssetDatasToCollection(const FCollectionScriptingRef& Collection, const TArray<FAssetData>& AssetDatas)
|
|
{
|
|
TArray<FSoftObjectPath> ObjectPaths;
|
|
ObjectPaths.Reserve(AssetDatas.Num());
|
|
Algo::Transform(AssetDatas, ObjectPaths, [](const FAssetData& AssetData) { return AssetData.GetSoftObjectPath(); });
|
|
|
|
return AddAssetsToCollection(Collection, ObjectPaths);
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::AddAssetPtrsToCollection(const FCollectionScriptingRef& Collection, const TArray<UObject*>& AssetPtrs)
|
|
{
|
|
TArray<FSoftObjectPath> ObjectPaths;
|
|
ObjectPaths.Reserve(AssetPtrs.Num());
|
|
Algo::Transform(AssetPtrs, ObjectPaths, [](const UObject* AssetPtr) { return FSoftObjectPath(AssetPtr); });
|
|
|
|
return AddAssetsToCollection(Collection, ObjectPaths);
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RemoveAssetFromCollection(const FCollectionScriptingRef& Collection, const FSoftObjectPath& AssetPath)
|
|
{
|
|
return RemoveAssetsFromCollection(Collection, TArray<FSoftObjectPath>({ AssetPath }));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RemoveAssetDataFromCollection(const FCollectionScriptingRef& Collection, const FAssetData& AssetData)
|
|
{
|
|
return RemoveAssetsFromCollection(Collection, TArray<FSoftObjectPath>({ AssetData.GetSoftObjectPath() }));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RemoveAssetPtrFromCollection(const FCollectionScriptingRef& Collection, const UObject* AssetPtr)
|
|
{
|
|
return RemoveAssetsFromCollection(Collection, TArray<FSoftObjectPath>({ FSoftObjectPath(AssetPtr) }));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RemoveAssetsFromCollection(const FCollectionScriptingRef& Collection, const TArray<FSoftObjectPath>& AssetPaths)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
FText Error;
|
|
if (!CollectionContainer->RemoveFromCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType), AssetPaths, nullptr, &Error))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(Error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RemoveAssetDatasFromCollection(const FCollectionScriptingRef& Collection, const TArray<FAssetData>& AssetDatas)
|
|
{
|
|
TArray<FSoftObjectPath> ObjectPaths;
|
|
ObjectPaths.Reserve(AssetDatas.Num());
|
|
Algo::Transform(AssetDatas, ObjectPaths, [](const FAssetData& AssetData) { return AssetData.GetSoftObjectPath(); });
|
|
|
|
return RemoveAssetsFromCollection(Collection, ObjectPaths);
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::RemoveAssetPtrsFromCollection(const FCollectionScriptingRef& Collection, const TArray<UObject*>& AssetPtrs)
|
|
{
|
|
TArray<FSoftObjectPath> ObjectPaths;
|
|
ObjectPaths.Reserve(AssetPtrs.Num());
|
|
Algo::Transform(AssetPtrs, ObjectPaths, [](const UObject* AssetPtr) { return FSoftObjectPath(AssetPtr); });
|
|
|
|
return RemoveAssetsFromCollection(Collection, ObjectPaths);
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::CollectionExists(const FCollectionScriptingContainerSource Container, const FName Collection, const ECollectionScriptingShareType ShareType)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Container.Name);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Container.Name) }));
|
|
return false;
|
|
}
|
|
|
|
return CollectionContainer->CollectionExists(Collection, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(ShareType));
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::GetCollectionsByName(const FCollectionScriptingContainerSource Container, const FName Collection, TArray<FCollectionScriptingRef>& OutCollections)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Container.Name);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Container.Name) }));
|
|
return false;
|
|
}
|
|
|
|
TArray<FCollectionNameType> FoundCollections;
|
|
CollectionContainer->GetCollections(Collection, FoundCollections);
|
|
|
|
OutCollections.Reserve(FoundCollections.Num());
|
|
Algo::Transform(FoundCollections, OutCollections, [ContainerName = Container.Name](const FCollectionNameType& Collection)
|
|
{
|
|
return FCollectionScriptingRef {
|
|
.Container = ContainerName,
|
|
.Name = Collection.Name,
|
|
.ShareType = CollectionManagerScriptingSubsystemUtil::ECollectionShareType_To_ECollectionScriptingShareType(Collection.Type)
|
|
};
|
|
});
|
|
|
|
return OutCollections.Num() > 0;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::GetAssetsInCollection(const FCollectionScriptingRef& Collection, TArray<FAssetData>& OutAssets)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Collection.Container);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
if (!CollectionContainer->CollectionExists(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType)))
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().CollectionNotFound,
|
|
{ FText::FromName(Collection.Name), FText::FromString(CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_String(Collection.ShareType)), FText::FromName(Collection.Container) }));
|
|
return false;
|
|
}
|
|
|
|
TArray<FSoftObjectPath> Assets;
|
|
CollectionContainer->GetAssetsInCollection(Collection.Name, CollectionManagerScriptingSubsystemUtil::ECollectionScriptingShareType_To_ECollectionShareType(Collection.ShareType), Assets);
|
|
|
|
const IAssetRegistry& AssetRegistry = IAssetRegistry::GetChecked();
|
|
OutAssets.Reserve(Assets.Num());
|
|
for (const FSoftObjectPath& Asset : Assets)
|
|
{
|
|
FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(Asset);
|
|
if (AssetData.IsValid())
|
|
{
|
|
OutAssets.Emplace(MoveTemp(AssetData));
|
|
}
|
|
else
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().FailedToGetAsset, { FText::FromString(Asset.ToString()), FText::FromName(Collection.Name) }));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::GetCollectionsContainingAsset(const FCollectionScriptingContainerSource Container, const FSoftObjectPath& AssetPath, TArray<FCollectionScriptingRef>& OutCollections)
|
|
{
|
|
const TSharedPtr<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().FindCollectionContainer(Container.Name);
|
|
if (!CollectionContainer.IsValid())
|
|
{
|
|
CollectionManagerScriptingSubsystemUtil::LogLastCollectionManagerError(FText::Format(CollectionManagerScriptingSubsystemUtil::FConstants::Get().ContainerNotFound, { FText::FromName(Container.Name) }));
|
|
return false;
|
|
}
|
|
|
|
TArray<FCollectionNameType> CollectionNamesAndTypes;
|
|
CollectionContainer->GetCollectionsContainingObject(AssetPath, CollectionNamesAndTypes);
|
|
|
|
OutCollections.Reserve(CollectionNamesAndTypes.Num());
|
|
for (const FCollectionNameType& CollectionNameAndType : CollectionNamesAndTypes)
|
|
{
|
|
OutCollections.Emplace(FCollectionScriptingRef{ .Container = Container.Name, .Name = CollectionNameAndType.Name, .ShareType = CollectionManagerScriptingSubsystemUtil::ECollectionShareType_To_ECollectionScriptingShareType(CollectionNameAndType.Type) });
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::GetCollectionsContainingAssetData(const FCollectionScriptingContainerSource Container, const FAssetData& AssetData, TArray<FCollectionScriptingRef>& OutCollections)
|
|
{
|
|
return GetCollectionsContainingAsset(Container, AssetData.GetSoftObjectPath(), OutCollections);
|
|
}
|
|
|
|
bool UCollectionManagerScriptingSubsystem::GetCollectionsContainingAssetPtr(const FCollectionScriptingContainerSource Container, const UObject* AssetPtr, TArray<FCollectionScriptingRef>& OutCollections)
|
|
{
|
|
return GetCollectionsContainingAsset(Container, FSoftObjectPath(AssetPtr), OutCollections);
|
|
}
|
|
|
|
FCollectionScriptingContainerSource UCollectionManagerScriptingSubsystem::GetBaseGameCollectionContainer() const
|
|
{
|
|
FCollectionScriptingContainerSource Container;
|
|
const TSharedRef<ICollectionContainer> CollectionContainer = FCollectionManagerModule::GetModule().Get().GetProjectCollectionContainer();
|
|
Container.Name = CollectionContainer->GetCollectionSource()->GetName();
|
|
Container.Title = CollectionContainer->GetCollectionSource()->GetTitle();
|
|
|
|
return Container;
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|