363 lines
17 KiB
C++
363 lines
17 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
#pragma once
|
|
|
|
#include "JsonObjectConverter.h"
|
|
#include "MetasoundAssetKey.h"
|
|
#include "MetasoundDocumentInterface.h"
|
|
#include "MetasoundFrontendDocument.h"
|
|
#include "MetasoundFrontendQuery.h"
|
|
#include "MetasoundFrontendRegistryKey.h"
|
|
#include "MetasoundVertex.h"
|
|
#include "UObject/AssetRegistryTagsContext.h"
|
|
#include "UObject/Object.h"
|
|
#include "UObject/Package.h"
|
|
#include "UObject/SoftObjectPath.h"
|
|
#include "UObject/TopLevelAssetPath.h"
|
|
#include "UObject/UObjectGlobals.h"
|
|
#include "UObject/WeakObjectPtrTemplates.h"
|
|
|
|
#include "MetasoundAssetManager.generated.h"
|
|
|
|
#define UE_API METASOUNDFRONTEND_API
|
|
|
|
|
|
// Forward Declarations
|
|
class FMetasoundAssetBase;
|
|
class UEdGraph;
|
|
|
|
class IMetaSoundDocumentInterface;
|
|
|
|
struct FAssetData;
|
|
struct FMetasoundFrontendClassName;
|
|
struct FMetaSoundFrontendDocumentBuilder;
|
|
|
|
|
|
USTRUCT(BlueprintType, DisplayName = "MetaSound Document Info")
|
|
struct FMetaSoundDocumentInfo
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
UE_API FMetaSoundDocumentInfo();
|
|
UE_API FMetaSoundDocumentInfo(const IMetaSoundDocumentInterface& InDocInterface);
|
|
UE_API FMetaSoundDocumentInfo(const FAssetData& InAssetData, bool& bOutIsValid);
|
|
|
|
UE_API void ExportToContext(FAssetRegistryTagsContext& OutContext) const;
|
|
|
|
// Version of document
|
|
UPROPERTY(BlueprintReadOnly, Category = DocumentInfo)
|
|
FMetasoundFrontendVersionNumber DocumentVersion;
|
|
|
|
// Versions of referenced asset class keys
|
|
UPROPERTY()
|
|
TArray<FMetaSoundAssetKey> ReferencedAssetKeys;
|
|
|
|
// Whether asset is a preset or not.
|
|
UPROPERTY(BlueprintReadOnly, Category = DocumentInfo)
|
|
uint8 bIsPreset : 1;
|
|
};
|
|
|
|
namespace Metasound::Frontend
|
|
{
|
|
namespace AssetTags
|
|
{
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FString METASOUNDFRONTEND_API ArrayDelim;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FName METASOUNDFRONTEND_API IsPreset;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FName METASOUNDFRONTEND_API AssetClassID;
|
|
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FName METASOUNDFRONTEND_API RegistryVersionMajor;
|
|
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FName METASOUNDFRONTEND_API RegistryVersionMinor;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FName METASOUNDFRONTEND_API RegistryInputTypes;
|
|
|
|
UE_DEPRECATED(5.6, "AssetTags no longer public. Construct FMetaSoundAssetClassInfo from AssetData to parse tag fields.")
|
|
extern const FName METASOUNDFRONTEND_API RegistryOutputTypes;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
} // namespace AssetTags
|
|
|
|
|
|
struct FMetaSoundAssetRegistrationOptions
|
|
{
|
|
// If true, forces a re-register of this class (and all class dependencies
|
|
// if the following option 'bRegisterDependencies' is enabled).
|
|
bool bForceReregister = true;
|
|
|
|
// If true, forces flag to resync all view (editor) data pertaining to the given asset(s) being registered.
|
|
bool bForceViewSynchronization = true;
|
|
|
|
// If true, recursively attempts to register dependencies. (TODO: Determine if this option should be removed.
|
|
// Must validate that failed dependency updates due to auto-update for ex. being disabled is handled gracefully
|
|
// at runtime.)
|
|
bool bRegisterDependencies = true;
|
|
|
|
// Attempt to auto-update (Only runs if class not registered or set to force re-register.
|
|
// Will not respect being set to true if project-level MetaSoundSettings specify to not run auto-update.)
|
|
bool bAutoUpdate = true;
|
|
|
|
// If true, warnings will be logged if updating a node results in existing connections being discarded.
|
|
bool bAutoUpdateLogWarningOnDroppedConnection = false;
|
|
|
|
#if WITH_EDITOR
|
|
// Soft deprecated. Preprocessing now handled contextually if cooking or serializing.
|
|
bool bPreprocessDocument = true;
|
|
|
|
// Attempt to rebuild referenced classes (only run if class not registered or set to force re-register)
|
|
bool bRebuildReferencedAssetClasses = true;
|
|
|
|
// No longer used. Memory management of document (i.e. copying or using object's version) inferred internally
|
|
bool bRegisterCopyIfAsync = false;
|
|
#endif // WITH_EDITOR
|
|
};
|
|
|
|
|
|
/** At runtime, contains a minimal set of information needed to further query additional
|
|
* class data from the Node Class Registries. At edit-time, contains this plus additional
|
|
* data useful for informing user of applicable asset classes within given edit contexts
|
|
* (see 'FMetaSoundEditorGraphSchema').
|
|
*/
|
|
struct FMetaSoundAssetClassInfo : public FMetaSoundClassInfo
|
|
{
|
|
FMetaSoundAssetClassInfo() = default;
|
|
UE_API FMetaSoundAssetClassInfo(const IMetaSoundDocumentInterface& InDocInterface);
|
|
|
|
// Attempts to transform AssetTag data from the given AssetData to this class info (asset may or
|
|
// may not be loaded). bIsValid set to false if object isn't loaded and any fields fail to load/are
|
|
// not serialized (i.e. tags are out-of-date).
|
|
UE_API FMetaSoundAssetClassInfo(const FAssetData& InAssetData);
|
|
|
|
// Exports tag data to the given RegistryContext
|
|
UE_API virtual void ExportToContext(FAssetRegistryTagsContext& OutContext) const override;
|
|
|
|
// If asset is loaded, retrieves asset key from loaded data. Otherwise, parses just the
|
|
// tag data necessary to get the given asset's asset key. Does not attempt to load asset,
|
|
// and will fail if data is not found and asset isn't loaded.
|
|
static UE_API bool TryGetAssetKey(const FAssetData& InAssetData, FMetaSoundAssetKey& OutKey);
|
|
|
|
// If asset is loaded, retrieves asset class name from loaded data. Otherwise, parses just the
|
|
// tag data necessary to get the given asset's class name. Does not attempt to load asset,
|
|
// and will fail if data is not found and asset isn't loaded.
|
|
static UE_API bool TryGetAssetClassName(const FAssetData& InAssetData, FMetasoundFrontendClassName& OutClassName);
|
|
|
|
protected:
|
|
UE_API virtual void InitFromDocument(const IMetaSoundDocumentInterface& InDocInterface) override;
|
|
|
|
private:
|
|
static UE_API bool TryGetAssetClassTag(const FAssetData& InAssetData, FString& OutClassIDString);
|
|
|
|
public:
|
|
// Path to asset containing graph if external type and references asset class.
|
|
FTopLevelAssetPath AssetPath;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
FMetaSoundDocumentInfo DocInfo;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
};
|
|
|
|
|
|
class IMetaSoundAssetManager
|
|
{
|
|
public:
|
|
virtual ~IMetaSoundAssetManager() = default;
|
|
|
|
static UE_API IMetaSoundAssetManager* Get();
|
|
static UE_API IMetaSoundAssetManager& GetChecked();
|
|
static UE_API void Deinitialize();
|
|
static UE_API void Initialize(TUniquePtr<IMetaSoundAssetManager>&& InInterface);
|
|
|
|
UE_DEPRECATED(5.5, "Use Initialize/Deinitialize instead")
|
|
UE_API virtual bool IsTesting() const;
|
|
|
|
UE_DEPRECATED(5.5, "Use Initialize/Deinitialize instead")
|
|
static void Set(IMetaSoundAssetManager& InInterface) { checkNoEntry(); }
|
|
|
|
// Passed template function pointer to execute in certain contexts when a MetaSound object is either already
|
|
// loaded or has completed asynchronous load. Due to some implementation restrictions when constructing
|
|
// FLoadPackageAsyncDelegate, this has to be a copyable function (vs. TUniqueFunction).
|
|
using FOnUpdatedAssetLoaded = TFunction<void(FMetaSoundAssetKey, UObject&)>;
|
|
|
|
struct FAssetRef
|
|
{
|
|
FMetaSoundAssetKey Key;
|
|
FTopLevelAssetPath Path;
|
|
|
|
FORCEINLINE friend bool operator==(const FAssetRef& InLHS, const FAssetRef& InRHS)
|
|
{
|
|
return (InLHS.Key == InRHS.Key) && (InLHS.Path == InRHS.Path);
|
|
}
|
|
|
|
FORCEINLINE friend uint32 GetTypeHash(const FAssetRef& InInfo)
|
|
{
|
|
return HashCombineFast(GetTypeHash(InInfo.Key), GetTypeHash(InInfo.Path));
|
|
}
|
|
};
|
|
|
|
struct UE_DEPRECATED(5.6, "Use FAssetRef instead") FAssetInfo
|
|
{
|
|
FNodeRegistryKey RegistryKey;
|
|
FSoftObjectPath AssetPath;
|
|
|
|
FORCEINLINE friend bool operator==(const FAssetInfo& InLHS, const FAssetInfo& InRHS)
|
|
{
|
|
return (InLHS.RegistryKey == InRHS.RegistryKey) && (InLHS.AssetPath == InRHS.AssetPath);
|
|
}
|
|
|
|
FORCEINLINE friend uint32 GetTypeHash(const FAssetInfo& InInfo)
|
|
{
|
|
return HashCombineFast(GetTypeHash(InInfo.RegistryKey), GetTypeHash(InInfo.AssetPath));
|
|
}
|
|
};
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
struct FVersionAssetResults
|
|
{
|
|
TArray<FTopLevelAssetPath> FailedPackages;
|
|
TArray<UPackage*> PackagesToReserialize;
|
|
TArray<FTopLevelAssetPath> PackagesUpToDate;
|
|
|
|
// Returns whether or not documents were found and loaded/attempted to version
|
|
bool DocumentsFoundInPackages() const
|
|
{
|
|
return !PackagesToReserialize.IsEmpty() || !PackagesUpToDate.IsEmpty() || !FailedPackages.IsEmpty();
|
|
}
|
|
};
|
|
|
|
// Adds missing assets using the provided asset's local reference class cache. Used
|
|
// to prime system from asset attempting to register prior to asset scan being complete.
|
|
// Returns true if references were added, false if it they are already found.
|
|
virtual bool AddAssetReferences(FMetasoundAssetBase& InAssetBase) = 0;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
UE_DEPRECATED(5.6, "Moved to AddOrUpdateFromObject")
|
|
virtual FMetaSoundAssetKey AddOrUpdateAsset(const UObject& InObject) { return { }; }
|
|
|
|
UE_DEPRECATED(5.6, "Moved to AddOrLoadAndUpdateFromObjectAsync")
|
|
virtual FMetaSoundAssetKey AddOrUpdateAsset(const FAssetData& InAssetData) { return { }; }
|
|
|
|
// Add or Update a MetaSound Asset's entry data from a loaded MetaSound asset UObject.
|
|
virtual FMetaSoundAssetKey AddOrUpdateFromObject(const UObject& InObject) = 0;
|
|
|
|
// Add or Update a MetaSound Asset's entry data from an object, loading it if it isn't already. On initial call, requests object load
|
|
// asynchronously and runs provided function on successful completion. If asset is already loaded, runs provided function immediately
|
|
// on entry update (synchronously).
|
|
virtual void AddOrLoadAndUpdateFromObjectAsync(const FAssetData& InAssetData, FOnUpdatedAssetLoaded&& OnUpdatedAssetLoaded) = 0;
|
|
|
|
// Add or Update a MetaSound Asset's entry data from AssetData. Potentially loads asset
|
|
// and adds asynchronously if asset or associated tag schema is out-of-date.
|
|
virtual void AddOrUpdateFromAssetData(const FAssetData& InAssetData) = 0;
|
|
|
|
// Whether or not the class is eligible for auto-update
|
|
virtual bool CanAutoUpdate(const FMetasoundFrontendClassName& InClassName) const = 0;
|
|
|
|
// Whether or not the asset manager has loaded the given asset
|
|
virtual bool ContainsKey(const FMetaSoundAssetKey& InAssetKey) const = 0;
|
|
|
|
// Whether or not the asset manager has loaded one or more assets with the given registry key.
|
|
// Returns false if key is not valid asset key (ex. input or output class key, variable, etc.)
|
|
virtual bool ContainsKey(const Metasound::Frontend::FNodeRegistryKey& InRegistryKey) const = 0;
|
|
|
|
// Returns object (if loaded) associated with the given key (null if key not registered with the AssetManager)
|
|
// If multiple assets are associated with the given key, the last one is returned.
|
|
virtual FMetasoundAssetBase* FindAsset(const FMetaSoundAssetKey& InAssetKey) const = 0;
|
|
|
|
// Returns object (if loaded) associated with the given key as a Document Interface (null if key not registered with the AssetManager)
|
|
virtual TScriptInterface<IMetaSoundDocumentInterface> FindAssetAsDocumentInterface(const FMetaSoundAssetKey& InKey) const = 0;
|
|
|
|
// Returns path associated with the given key (returns invalid asset path if key not registered with the AssetManager or was not loaded from asset)
|
|
// If multiple assets are associated with the given key, the last one is returned.
|
|
virtual FTopLevelAssetPath FindAssetPath(const FMetaSoundAssetKey& InAssetKey) const = 0;
|
|
|
|
// Returns all paths associated with the given key (returns empty array if key not registered with the AssetManager or was not loaded from asset)
|
|
virtual TArray<FTopLevelAssetPath> FindAssetPaths(const FMetaSoundAssetKey& InAssetKey) const = 0;
|
|
|
|
// Converts an object to an AssetBase if its a registered asset
|
|
virtual FMetasoundAssetBase* GetAsAsset(UObject& InObject) const = 0;
|
|
virtual const FMetasoundAssetBase* GetAsAsset(const UObject& InObject) const = 0;
|
|
|
|
#if WITH_EDITOR
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
UE_DEPRECATED(5.6, "Use GetReferencedAssets instead")
|
|
virtual TSet<FAssetInfo> GetReferencedAssetClasses(const FMetasoundAssetBase& InAssetBase) const { return { }; }
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
|
|
// Generates all asset info associated with registered assets that are referenced by the provided asset's graph.
|
|
virtual TSet<FAssetRef> GetReferencedAssets(const FMetasoundAssetBase& InAssetBase) const = 0;
|
|
|
|
// Get assets this asset is a preset of, recursively for presets of presets.
|
|
// This means finding all references including the last non preset, but not graphs used directly in non-preset composition.
|
|
// Ex. MetaSound A is a preset of MetaSound B, which is a preset of MetaSound C, which references D by composition -> When called on A, will return B and C.
|
|
// If not a preset, returns false.
|
|
virtual bool GetReferencedPresetHierarchy(FMetasoundAssetBase& InAsset, TArray<FMetasoundAssetBase*>& OutReferencedAssets) const = 0;
|
|
#endif // WITH_EDITOR
|
|
|
|
// returns whether or not the given class is defined as a registered asset
|
|
virtual bool IsAssetClass(const FMetasoundFrontendClassMetadata& ClassMetadata) const = 0;
|
|
|
|
UE_DEPRECATED(5.6, "Moved to Iterate ClassInfo")
|
|
virtual void IterateAssets(TFunctionRef<void(const FMetaSoundAssetKey, const TArray<FTopLevelAssetPath>&)> Iter) const { }
|
|
|
|
UE_DEPRECATED(5.5, "Rescan no longer supported nor required by Frontend")
|
|
virtual void RescanAutoUpdateDenyList() { }
|
|
|
|
// Set flag for logging active assets on shutdown. In certain cases (ex. validation), it is expected that assets are active at shutdown
|
|
virtual void SetLogActiveAssetsOnShutdown(bool bLogActiveAssetsOnShutdown) = 0;
|
|
|
|
// Attempts to retrieve the AssetID from the given ClassName if the ClassName is from a valid asset.
|
|
virtual bool TryGetAssetIDFromClassName(const FMetasoundFrontendClassName& InClassName, FGuid& OutGuid) const = 0;
|
|
|
|
// Attempts to load an FMetasoundAssetBase from the given path, or returns it if its already loaded
|
|
virtual FMetasoundAssetBase* TryLoadAsset(const FSoftObjectPath& InObjectPath) const = 0;
|
|
|
|
// Returns asset associated with the given key (null if key not registered with the AssetManager or was not loaded from asset)
|
|
virtual FMetasoundAssetBase* TryLoadAssetFromKey(const FMetaSoundAssetKey& InAssetKey) const = 0;
|
|
|
|
// Try to load referenced assets of the given asset or return them if they are already loaded (non-recursive).
|
|
// @return - True if all referenced assets successfully loaded, false if not.
|
|
virtual bool TryLoadReferencedAssets(const FMetasoundAssetBase& InAssetBase, TArray<FMetasoundAssetBase*>& OutReferencedAssets) const = 0;
|
|
|
|
#if WITH_EDITOR
|
|
// Assigns a new arbitrary class name to the given document, which can cause references to be invalidated.
|
|
// (See
|
|
virtual bool ReassignClassName(TScriptInterface<IMetaSoundDocumentInterface> DocInterface) = 0;
|
|
#endif // WITH_EDITOR
|
|
|
|
// Requests an async load of all async referenced assets of the input asset.
|
|
virtual void RequestAsyncLoadReferencedAssets(FMetasoundAssetBase& InAssetBase) = 0;
|
|
|
|
// Synchronously requests unregister and re-register of all loaded MetaSound assets node class entries.
|
|
virtual void ReloadMetaSoundAssets() const = 0;
|
|
|
|
// Removes object from MetaSound asset manager
|
|
virtual void RemoveAsset(const UObject& InObject) = 0;
|
|
|
|
// Removes object from MetaSound asset manager
|
|
virtual void RemoveAsset(const FAssetData& InAssetData) = 0;
|
|
|
|
// Updates the given MetaSound's asset record with the new name and optionally reregisters it with the Frontend Node Class Registry.
|
|
virtual void RenameAsset(const FAssetData& InAssetData, const FString& InOldObjectPath) = 0;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
// Versions all MetaSound asset tags & documents found within the given folder paths. Optionally, recurses the given paths.
|
|
// Populates the provided array with MetaSound packages whose document versions were out-of-date and consequently updated.
|
|
// Returns resulting versioned and unversioned paths.
|
|
virtual FVersionAssetResults VersionAssetsInFolders(const TArray<FString>& FolderPaths, bool bRecursePaths = true) const = 0;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
// Waits until all async load requests related to this asset are complete.
|
|
virtual void WaitUntilAsyncLoadReferencedAssetsComplete(FMetasoundAssetBase& InAssetBase) = 0;
|
|
};
|
|
} // namespace Metasound::Frontend
|
|
|
|
#undef UE_API
|