ArticyDatabase.h

//  
// Copyright (c) 2023 articy Software GmbH & Co. KG. All rights reserved.  
//
 
#pragma once
 
#include "Engine/DataAsset.h"
#include "ArticyBaseObject.h"
#include "ShadowStateManager.h"
#include "ArticyObject.h"
#include "ArticyPackage.h"
#include "AssetRegistry/AssetData.h"
#include "ArticyDatabase.generated.h"
 
class UArticyExpressoScripts;
struct FArticyId;
class UArticyGlobalVariables;
class UArticyAlternativeGlobalVariables;

USTRUCT(BlueprintType)
struct FArticyObjectShadow
{
    GENERATED_BODY()
 
    
    FArticyObjectShadow() {}
    FArticyObjectShadow(uint32 ShadowLevel, UArticyObject* Object, int32 CloneId, UObject* Outer = nullptr)
        : ShadowLevel(ShadowLevel), Object(Object), Outer(Outer), CloneId(CloneId) {}
 
public:
    UPROPERTY()
    uint32 ShadowLevel = 0; 
    UArticyObject* GetObject();
    int32 GetCloneId() const { return CloneId; }
private:
    UPROPERTY()
    UArticyObject* Object = nullptr; 
 
    TWeakObjectPtr<UObject> Outer; 
 
    int32 CloneId; 
};

USTRUCT(BlueprintType)
struct ARTICYRUNTIME_API FArticyShadowableObject
{
    GENERATED_BODY()
 
public:
    FArticyShadowableObject() = default;
    explicit FArticyShadowableObject(UArticyObject* Object, int32 CloneId, UObject* Outer = nullptr);

    UArticyObject* Get(const IShadowStateManager* ShadowManager, bool ForceUnshadowed = false) const;
 
private:

    UPROPERTY(VisibleAnywhere, Category = "Articy")
    mutable TArray<FArticyObjectShadow> ShadowCopies;
};

UCLASS(BlueprintType)
class ARTICYRUNTIME_API UArticyCloneableObject : public UObject
{
    GENERATED_BODY()
 
public:
    void Init(UArticyObject* InitialClone) { AddClone(InitialClone, 0); }
 
    //========================================//

    UArticyObject* Get(const IShadowStateManager* ShadowManager, int32 CloneId = 0, bool bForceUnshadowed = false) const;
    UArticyObject* Clone(const IShadowStateManager* ShadowManager, int32 CloneId, bool bFailIfExists = true);
 
private:

    UPROPERTY(VisibleAnywhere, Category = "Articy")
    TMap<int32, FArticyShadowableObject> Clones;

    void AddClone(UArticyObject* Clone, int32 CloneId);
};

USTRUCT(BlueprintType)
struct ARTICYRUNTIME_API FArticyDatabaseObjectArray
{
    GENERATED_BODY()
 
public:
    UPROPERTY()
    TArray<UArticyCloneableObject*> Objects; 
};

UCLASS(Config = Game)
class ARTICYRUNTIME_API UArticyDatabase : public UDataAsset, public IShadowStateManager
{
    GENERATED_BODY()
 
public:
 
    UArticyDatabase();

    virtual FPrimaryAssetId GetPrimaryAssetId() const override { return FPrimaryAssetId(FName(TEXT("ArticyDatabase")), GetFName()); }

    void Init();

    UFUNCTION(BlueprintCallable, Category = "Articy|Lifecycle")
    static void Initialize(const UObject* WorldContext);

    UFUNCTION(BlueprintCallable, Category = "Articy|Lifecycle")
    static void Deinitialize(const UObject* WorldContext);

    static UArticyDatabase* Get(const UObject* WorldContext);

    virtual UArticyGlobalVariables* GetGVs() const;
    virtual UArticyGlobalVariables* GetRuntimeGVs(UArticyAlternativeGlobalVariables* Asset) const;

    UFUNCTION(BlueprintCallable, Category = "Articy")
    void UnloadDatabase();

    UFUNCTION(BlueprintCallable, Category = "Script Methods")
    void SetDefaultUserMethodsProvider(UObject* MethodProvider);

    UFUNCTION(BlueprintPure, meta = (DisplayName = "Is in shadow state?"), Category = "Script Methods")
    bool IsInShadowState() const { return GetShadowLevel() > 0; }

    UFUNCTION(BlueprintPure, meta = (DisplayName = "Get imported package names"), Category = "Articy")
    TArray<FString> GetImportedPackageNames() const;

    UFUNCTION(BlueprintPure, meta = (DisplayName = "Is package default package?"), Category = "Articy")
    bool IsPackageDefaultPackage(FString PackageName);
 
    //---------------------------------------------------------------------------//

    static void LoadAllObjects();

    virtual void SetLoadedPackages(const TArray<UArticyPackage*> Packages);

    virtual void LoadDefaultPackages();

    virtual void LoadAllPackages(bool bDefaultOnly = false);

    UFUNCTION(BlueprintCallable, Category = "Articy")
    virtual void LoadPackage(FString PackageName);

    UFUNCTION(BlueprintCallable, Category = "Articy")
    virtual bool UnloadPackage(const FString PackageName, const bool bQuickUnload);
 
    //---------------------------------------------------------------------------//

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo", AdvancedDisplay = "CloneId"))
    UArticyObject* GetObject(FArticyId Id, int32 CloneId = 0, TSubclassOf<class UArticyObject> CastTo = NULL) const;
    template<typename T>
    T* GetObject(FArticyId Id, int32 CloneId = 0) const { return Cast<T>(GetObject(Id, CloneId)); }

    UArticyObject* GetObjectUnshadowed(FArticyId Id, int32 CloneId = 0) const;

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo", AdvancedDisplay = "CloneId"))
    UArticyObject* GetObjectByName(FName TechnicalName, int32 CloneId = 0, TSubclassOf<class UArticyObject> CastTo = NULL) const;
    template<typename T>
    T* GetObjectByName(FName TechnicalName, int32 CloneId = 0) const { return Cast<T>(GetObjectByName(TechnicalName, CloneId)); }
 
    /****
    * Get an object by its Articy String Representation.
    * Use this method to get an Articy Id from a Global Variable String typed
    * that contains the result of an Expresso GetObj(---) method.
    * @param StringID_CloneID The string representation of the object's ID and clone ID.
    * @param CastTo The class to cast the object to.
    * @return A pointer to the Articy object, or nullptr if not found.
    *****/
    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo", AdvancedDisplay = "CloneId"))
    UArticyObject* GetObjectFromStringRepresentation(FString StringID_CloneID, TSubclassOf<class UArticyObject> CastTo = NULL) const;
    template<typename T>
    T* GetObjectFromStringRepresentation(FString StringID_CloneID) const { return Cast<T>(GetObjectFromStringRepresentation(StringID_CloneID)); }

    template<typename T>
    TArray<T*> GetObjects(FName TechnicalName, int32 CloneId = 0) const;
    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo", AdvancedDisplay = "CloneId"))
    TArray<UArticyObject*> GetObjects(FName TechnicalName, int32 CloneId = 0, TSubclassOf<class UArticyObject> CastTo = NULL) const;

    template<typename T>
    TArray<T*> GetObjectsOfClass(int32 CloneId = 0) const;

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "Class", AdvancedDisplay = "CloneId"))
    TArray<UArticyObject*> GetObjectsOfClass(TSubclassOf<class UArticyObject> Class, int32 CloneId = 0) const;

    UFUNCTION(BlueprintCallable, Category = "Articy")
    TArray<UArticyObject*> GetAllObjects() const;

    template<typename T = UArticyObject>
    void GetObjects(TArray<T*>& Array, FName TechnicalName, int32 CloneId = 0) const;
 
    //---------------------------------------------------------------------------//

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo"))
    UArticyObject* CloneFrom(FArticyId Id, int32 NewCloneId = -1, TSubclassOf<class UArticyObject> CastTo = NULL);
    template<typename T>
    T* CloneFrom(FArticyId Id, int32 NewCloneId = -1) { return Cast<T>(CloneFrom(Id, NewCloneId)); }

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo"))
    UArticyObject* CloneFromByName(FName TechnicalName, int32 NewCloneId = -1, TSubclassOf<class UArticyObject> CastTo = NULL);
    template<typename T>
    T* CloneFrom(FName TechnicalName, int32 NewCloneId = -1) { return Cast<T>(CloneFromByName(TechnicalName, NewCloneId)); }

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo"))
    UArticyObject* GetOrClone(FArticyId Id, int32 NewCloneId);
    template<typename T>
    T* GetOrClone(FArticyId Id, int32 NewCloneId) { return Cast<T>(GetOrClone(Id, NewCloneId)); }

    UFUNCTION(BlueprintCallable, Category = "Articy", meta = (DeterminesOutputType = "CastTo"))
    UArticyObject* GetOrCloneByName(const FName& TechnicalName, int32 NewCloneId);
    template<typename T>
    T* GetOrClone(const FName& TechnicalName, int32 NewCloneId) { return Cast<T>(GetOrCloneByName(TechnicalName, NewCloneId)); }
 
    //---------------------------------------------------------------------------//

    UArticyExpressoScripts* GetExpressoInstance() const;

    static TWeakObjectPtr<UArticyDatabase> GetMutableOriginal();

    void ChangePackageDefault(FName PackageName, bool bIsDefaultPackage);
 
    UFUNCTION(BlueprintCallable, Category = "Articy")
    void SetExpressoScriptsClass(TSubclassOf<UArticyExpressoScripts> NewClass);
 
protected:

    UPROPERTY(VisibleAnywhere, Category = "Articy")
    TMap<FString, UArticyPackage*> ImportedPackages;
 
    UPROPERTY(VisibleAnywhere, transient, Category = "Articy")
    TArray<FString> LoadedPackages;
 
    UPROPERTY()
    TMap<FArticyId, UArticyCloneableObject*> LoadedObjectsById;
    UPROPERTY()
    TMap<FName, FArticyDatabaseObjectArray> LoadedObjectsByName;
 
    UPROPERTY(Transient)
    bool bIsInitialized = false;
 
    void UnloadAllPackages();
 
private:
 
    static TMap<TWeakObjectPtr<UWorld>, TWeakObjectPtr<UArticyDatabase>> Clones;
    static TWeakObjectPtr<UArticyDatabase> PersistentClone;
 
    UPROPERTY()
    mutable UArticyExpressoScripts* CachedExpressoScripts;

    UPROPERTY(Config, VisibleAnywhere, Category = "Articy")
    TSubclassOf<UArticyExpressoScripts> ExpressoScriptsClass;
 
    UArticyObject* GetObjectInternal(FArticyId Id, int32 CloneId = 0, bool bForceUnshadowed = false) const;

    static const UArticyDatabase* GetOriginal(bool bLoadDefaultPackages = false);

    struct FAssetId
    {
        FName technicalName;
        FString s_uniqueID;
        uint64 uniqueID;
    };

    static FAssetId ResolveIDs(const FString& articyAssetFileName);
};
 
template<typename T>
TArray<T*> UArticyDatabase::GetObjects(FName TechnicalName, int32 CloneId) const
{
    static TArray<T*> Array;
    Array.Reset();
 
    GetObjects(Array, TechnicalName, CloneId);
 
    return Array;
}
 
template<typename T>
TArray<T*> UArticyDatabase::GetObjectsOfClass(int32 CloneId) const
{
    TArray<T*> arr;
 
    TArray<UArticyCloneableObject*> ArticyObjects;
    LoadedObjectsById.GenerateValueArray(ArticyObjects);
 
    for (auto obj : ArticyObjects)
    {
        /*if (obj->GetCloneId() == CloneId && Cast<T>(obj))
        {
            arr.Add(obj);
        }*/
 
        UArticyObject* Object = obj->Get(this, CloneId, false);
        if (Object)
        {
            T* TypedObject = Cast<T>(Object);
            if (TypedObject)
            {
                arr.Add(TypedObject);
            }
        }
    }
    return arr;
}
 
template<typename T>
void UArticyDatabase::GetObjects(TArray<T*>& Array, FName TechnicalName, int32 CloneId) const
{
    //find all objects with this name
    auto arr = LoadedObjectsByName.Find(TechnicalName);
    if (arr)
    {
        for (auto obj : arr->Objects)
        {
            auto clone = Cast<T>(obj->Clone(this, CloneId));
            if (clone)
                Array.Add(clone);
        }
    }
}