mirror of
https://github.com/swordbluesword/PalWorld-NetCrack.git
synced 2025-04-29 02:47:17 +09:00
1381 lines
48 KiB
C++
1381 lines
48 KiB
C++
#pragma once
|
|
|
|
// Dumped with Dumper-7!
|
|
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
// FUNCTIONS
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Class AssetRegistry.AssetRegistryHelpers
|
|
// (None)
|
|
|
|
class UClass* UAssetRegistryHelpers::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AssetRegistryHelpers");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AssetRegistryHelpers AssetRegistry.Default__AssetRegistryHelpers
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAssetRegistryHelpers* UAssetRegistryHelpers::GetDefaultObj()
|
|
{
|
|
static class UAssetRegistryHelpers* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAssetRegistryHelpers*>(UAssetRegistryHelpers::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.ToSoftObjectPath
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSoftObjectPath ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FSoftObjectPath UAssetRegistryHelpers::ToSoftObjectPath(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "ToSoftObjectPath");
|
|
|
|
Params::UAssetRegistryHelpers_ToSoftObjectPath_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.SetFilterTagsAndValues
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FARFilter InFilter (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TArray<struct FTagAndValue> InTagsAndValues (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FARFilter ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FARFilter UAssetRegistryHelpers::SetFilterTagsAndValues(struct FARFilter& InFilter, TArray<struct FTagAndValue>& InTagsAndValues)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "SetFilterTagsAndValues");
|
|
|
|
Params::UAssetRegistryHelpers_SetFilterTagsAndValues_Params Parms{};
|
|
|
|
Parms.InFilter = InFilter;
|
|
Parms.InTagsAndValues = InTagsAndValues;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.IsValid
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAssetRegistryHelpers::IsValid(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "IsValid");
|
|
|
|
Params::UAssetRegistryHelpers_IsValid_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.IsUAsset
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAssetRegistryHelpers::IsUAsset(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "IsUAsset");
|
|
|
|
Params::UAssetRegistryHelpers_IsUAsset_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.IsRedirector
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAssetRegistryHelpers::IsRedirector(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "IsRedirector");
|
|
|
|
Params::UAssetRegistryHelpers_IsRedirector_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.IsAssetLoaded
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAssetRegistryHelpers::IsAssetLoaded(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "IsAssetLoaded");
|
|
|
|
Params::UAssetRegistryHelpers_IsAssetLoaded_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetTagValue
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName InTagName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString OutTagValue (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAssetRegistryHelpers::GetTagValue(struct FAssetData& InAssetData, class FName& InTagName, class FString* OutTagValue)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetTagValue");
|
|
|
|
Params::UAssetRegistryHelpers_GetTagValue_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
Parms.InTagName = InTagName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutTagValue != nullptr)
|
|
*OutTagValue = std::move(Parms.OutTagValue);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetFullName
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UAssetRegistryHelpers::GetFullName(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetFullName");
|
|
|
|
Params::UAssetRegistryHelpers_GetFullName_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetExportTextName
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UAssetRegistryHelpers::GetExportTextName(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetExportTextName");
|
|
|
|
Params::UAssetRegistryHelpers_GetExportTextName_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetClass
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UClass* UAssetRegistryHelpers::GetClass(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetClass");
|
|
|
|
Params::UAssetRegistryHelpers_GetClass_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetBlueprintAssets
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FARFilter InFilter (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
|
|
void UAssetRegistryHelpers::GetBlueprintAssets(struct FARFilter& InFilter, TArray<struct FAssetData>* OutAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetBlueprintAssets");
|
|
|
|
Params::UAssetRegistryHelpers_GetBlueprintAssets_Params Parms{};
|
|
|
|
Parms.InFilter = InFilter;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetAssetRegistry
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TScriptInterface<class IAssetRegistry>ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
TScriptInterface<class IAssetRegistry> UAssetRegistryHelpers::GetAssetRegistry()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetAssetRegistry");
|
|
|
|
Params::UAssetRegistryHelpers_GetAssetRegistry_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.GetAsset
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAssetData InAssetData (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UObject* UAssetRegistryHelpers::GetAsset(struct FAssetData& InAssetData)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "GetAsset");
|
|
|
|
Params::UAssetRegistryHelpers_GetAsset_Params Parms{};
|
|
|
|
Parms.InAssetData = InAssetData;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistryHelpers.CreateAssetData
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* InAsset (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bAllowBlueprintClass (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAssetData ReturnValue (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FAssetData UAssetRegistryHelpers::CreateAssetData(class UObject* InAsset, bool bAllowBlueprintClass)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistryHelpers", "CreateAssetData");
|
|
|
|
Params::UAssetRegistryHelpers_CreateAssetData_Params Parms{};
|
|
|
|
Parms.InAsset = InAsset;
|
|
Parms.bAllowBlueprintClass = bAllowBlueprintClass;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AssetRegistry.AssetRegistry
|
|
// (None)
|
|
|
|
class UClass* IAssetRegistry::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AssetRegistry");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AssetRegistry AssetRegistry.Default__AssetRegistry
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class IAssetRegistry* IAssetRegistry::GetDefaultObj()
|
|
{
|
|
static class IAssetRegistry* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<IAssetRegistry*>(IAssetRegistry::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.WaitForPackage
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class FString PackageName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::WaitForPackage(const class FString& PackageName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "WaitForPackage");
|
|
|
|
Params::IAssetRegistry_WaitForPackage_Params Parms{};
|
|
|
|
Parms.PackageName = PackageName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.WaitForCompletion
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void IAssetRegistry::WaitForCompletion()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "WaitForCompletion");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.UseFilterToExcludeAssets
|
|
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// TArray<struct FAssetData> AssetDataList (Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FARFilter Filter (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::UseFilterToExcludeAssets(TArray<struct FAssetData>& AssetDataList, struct FARFilter& Filter)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "UseFilterToExcludeAssets");
|
|
|
|
Params::IAssetRegistry_UseFilterToExcludeAssets_Params Parms{};
|
|
|
|
Parms.AssetDataList = AssetDataList;
|
|
Parms.Filter = Filter;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.SearchAllAssets
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bSynchronousSearch (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::SearchAllAssets(bool bSynchronousSearch)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "SearchAllAssets");
|
|
|
|
Params::IAssetRegistry_SearchAllAssets_Params Parms{};
|
|
|
|
Parms.bSynchronousSearch = bSynchronousSearch;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.ScanPathsSynchronous
|
|
// (Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class FString> InPaths (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool bForceRescan (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIgnoreDenyListScanFilters (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::ScanPathsSynchronous(TArray<class FString>& InPaths, bool bForceRescan, bool bIgnoreDenyListScanFilters)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "ScanPathsSynchronous");
|
|
|
|
Params::IAssetRegistry_ScanPathsSynchronous_Params Parms{};
|
|
|
|
Parms.InPaths = InPaths;
|
|
Parms.bForceRescan = bForceRescan;
|
|
Parms.bIgnoreDenyListScanFilters = bIgnoreDenyListScanFilters;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.ScanModifiedAssetFiles
|
|
// (Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class FString> InFilePaths (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::ScanModifiedAssetFiles(TArray<class FString>& InFilePaths)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "ScanModifiedAssetFiles");
|
|
|
|
Params::IAssetRegistry_ScanModifiedAssetFiles_Params Parms{};
|
|
|
|
Parms.InFilePaths = InFilePaths;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.ScanFilesSynchronous
|
|
// (Native, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class FString> InFilePaths (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// bool bForceRescan (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::ScanFilesSynchronous(TArray<class FString>& InFilePaths, bool bForceRescan)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "ScanFilesSynchronous");
|
|
|
|
Params::IAssetRegistry_ScanFilesSynchronous_Params Parms{};
|
|
|
|
Parms.InFilePaths = InFilePaths;
|
|
Parms.bForceRescan = bForceRescan;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.RunAssetsThroughFilter
|
|
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// TArray<struct FAssetData> AssetDataList (Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FARFilter Filter (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::RunAssetsThroughFilter(TArray<struct FAssetData>& AssetDataList, struct FARFilter& Filter)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "RunAssetsThroughFilter");
|
|
|
|
Params::IAssetRegistry_RunAssetsThroughFilter_Params Parms{};
|
|
|
|
Parms.AssetDataList = AssetDataList;
|
|
Parms.Filter = Filter;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.PrioritizeSearchPath
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class FString PathToPrioritize (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::PrioritizeSearchPath(const class FString& PathToPrioritize)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "PrioritizeSearchPath");
|
|
|
|
Params::IAssetRegistry_PrioritizeSearchPath_Params Parms{};
|
|
|
|
Parms.PathToPrioritize = PathToPrioritize;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.K2_GetReferencers
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FName PackageName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAssetRegistryDependencyOptionsReferenceOptions (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// TArray<class FName> OutReferencers (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::K2_GetReferencers(class FName PackageName, struct FAssetRegistryDependencyOptions& ReferenceOptions, TArray<class FName>* OutReferencers)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "K2_GetReferencers");
|
|
|
|
Params::IAssetRegistry_K2_GetReferencers_Params Parms{};
|
|
|
|
Parms.PackageName = PackageName;
|
|
Parms.ReferenceOptions = ReferenceOptions;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutReferencers != nullptr)
|
|
*OutReferencers = std::move(Parms.OutReferencers);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.K2_GetDependencies
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FName PackageName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAssetRegistryDependencyOptionsDependencyOptions (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// TArray<class FName> OutDependencies (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::K2_GetDependencies(class FName PackageName, struct FAssetRegistryDependencyOptions& DependencyOptions, TArray<class FName>* OutDependencies)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "K2_GetDependencies");
|
|
|
|
Params::IAssetRegistry_K2_GetDependencies_Params Parms{};
|
|
|
|
Parms.PackageName = PackageName;
|
|
Parms.DependencyOptions = DependencyOptions;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutDependencies != nullptr)
|
|
*OutDependencies = std::move(Parms.OutDependencies);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.K2_GetAssetByObjectPath
|
|
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// struct FSoftObjectPath ObjectPath (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIncludeOnlyOnDiskAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAssetData ReturnValue (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FAssetData IAssetRegistry::K2_GetAssetByObjectPath(struct FSoftObjectPath& ObjectPath, bool bIncludeOnlyOnDiskAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "K2_GetAssetByObjectPath");
|
|
|
|
Params::IAssetRegistry_K2_GetAssetByObjectPath_Params Parms{};
|
|
|
|
Parms.ObjectPath = ObjectPath;
|
|
Parms.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.IsSearchAsync
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::IsSearchAsync()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "IsSearchAsync");
|
|
|
|
Params::IAssetRegistry_IsSearchAsync_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.IsSearchAllAssets
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::IsSearchAllAssets()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "IsSearchAllAssets");
|
|
|
|
Params::IAssetRegistry_IsSearchAllAssets_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.IsLoadingAssets
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::IsLoadingAssets()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "IsLoadingAssets");
|
|
|
|
Params::IAssetRegistry_IsLoadingAssets_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.HasAssets
|
|
// (Native, Public, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FName PackagePath (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bRecursive (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::HasAssets(class FName PackagePath, bool bRecursive)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "HasAssets");
|
|
|
|
Params::IAssetRegistry_HasAssets_Params Parms{};
|
|
|
|
Parms.PackagePath = PackagePath;
|
|
Parms.bRecursive = bRecursive;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetSubPaths
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FString InBasePath (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<class FString> OutPathList (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bInRecurse (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::GetSubPaths(const class FString& InBasePath, TArray<class FString>* OutPathList, bool bInRecurse)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetSubPaths");
|
|
|
|
Params::IAssetRegistry_GetSubPaths_Params Parms{};
|
|
|
|
Parms.InBasePath = InBasePath;
|
|
Parms.bInRecurse = bInRecurse;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutPathList != nullptr)
|
|
*OutPathList = std::move(Parms.OutPathList);
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetDerivedClassNames
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// TArray<struct FTopLevelAssetPath> ClassNames (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TSet<struct FTopLevelAssetPath> ExcludedClassNames (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TSet<struct FTopLevelAssetPath> OutDerivedClassNames (Parm, OutParm, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::GetDerivedClassNames(TArray<struct FTopLevelAssetPath>& ClassNames, TSet<struct FTopLevelAssetPath>& ExcludedClassNames, TSet<struct FTopLevelAssetPath>* OutDerivedClassNames)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetDerivedClassNames");
|
|
|
|
Params::IAssetRegistry_GetDerivedClassNames_Params Parms{};
|
|
|
|
Parms.ClassNames = ClassNames;
|
|
Parms.ExcludedClassNames = ExcludedClassNames;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutDerivedClassNames != nullptr)
|
|
*OutDerivedClassNames = Parms.OutDerivedClassNames;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAssetsByPaths
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// TArray<class FName> PackagePaths (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bRecursive (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIncludeOnlyOnDiskAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAssetsByPaths(const TArray<class FName>& PackagePaths, TArray<struct FAssetData>* OutAssetData, bool bRecursive, bool bIncludeOnlyOnDiskAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAssetsByPaths");
|
|
|
|
Params::IAssetRegistry_GetAssetsByPaths_Params Parms{};
|
|
|
|
Parms.PackagePaths = PackagePaths;
|
|
Parms.bRecursive = bRecursive;
|
|
Parms.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAssetsByPath
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FName PackagePath (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bRecursive (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIncludeOnlyOnDiskAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAssetsByPath(class FName PackagePath, TArray<struct FAssetData>* OutAssetData, bool bRecursive, bool bIncludeOnlyOnDiskAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAssetsByPath");
|
|
|
|
Params::IAssetRegistry_GetAssetsByPath_Params Parms{};
|
|
|
|
Parms.PackagePath = PackagePath;
|
|
Parms.bRecursive = bRecursive;
|
|
Parms.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAssetsByPackageName
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FName PackageName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bIncludeOnlyOnDiskAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bSkipARFilteredAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAssetsByPackageName(class FName PackageName, TArray<struct FAssetData>* OutAssetData, bool bIncludeOnlyOnDiskAssets, bool bSkipARFilteredAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAssetsByPackageName");
|
|
|
|
Params::IAssetRegistry_GetAssetsByPackageName_Params Parms{};
|
|
|
|
Parms.PackageName = PackageName;
|
|
Parms.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
|
|
Parms.bSkipARFilteredAssets = bSkipARFilteredAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAssetsByClass
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// struct FTopLevelAssetPath ClassPathName (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bSearchSubClasses (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAssetsByClass(const struct FTopLevelAssetPath& ClassPathName, TArray<struct FAssetData>* OutAssetData, bool bSearchSubClasses)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAssetsByClass");
|
|
|
|
Params::IAssetRegistry_GetAssetsByClass_Params Parms{};
|
|
|
|
Parms.ClassPathName = ClassPathName;
|
|
Parms.bSearchSubClasses = bSearchSubClasses;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAssets
|
|
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// struct FARFilter Filter (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bSkipARFilteredAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAssets(struct FARFilter& Filter, TArray<struct FAssetData>* OutAssetData, bool bSkipARFilteredAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAssets");
|
|
|
|
Params::IAssetRegistry_GetAssets_Params Parms{};
|
|
|
|
Parms.Filter = Filter;
|
|
Parms.bSkipARFilteredAssets = bSkipARFilteredAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAssetByObjectPath
|
|
// (Native, Public, HasDefaults, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// class FName ObjectPath (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bIncludeOnlyOnDiskAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAssetData ReturnValue (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FAssetData IAssetRegistry::GetAssetByObjectPath(class FName ObjectPath, bool bIncludeOnlyOnDiskAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAssetByObjectPath");
|
|
|
|
Params::IAssetRegistry_GetAssetByObjectPath_Params Parms{};
|
|
|
|
Parms.ObjectPath = ObjectPath;
|
|
Parms.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAncestorClassNames
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// struct FTopLevelAssetPath ClassPathName (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// TArray<struct FTopLevelAssetPath> OutAncestorClassNames (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAncestorClassNames(const struct FTopLevelAssetPath& ClassPathName, TArray<struct FTopLevelAssetPath>* OutAncestorClassNames)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAncestorClassNames");
|
|
|
|
Params::IAssetRegistry_GetAncestorClassNames_Params Parms{};
|
|
|
|
Parms.ClassPathName = ClassPathName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAncestorClassNames != nullptr)
|
|
*OutAncestorClassNames = std::move(Parms.OutAncestorClassNames);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAllCachedPaths
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// TArray<class FString> OutPathList (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
|
|
void IAssetRegistry::GetAllCachedPaths(TArray<class FString>* OutPathList)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAllCachedPaths");
|
|
|
|
Params::IAssetRegistry_GetAllCachedPaths_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutPathList != nullptr)
|
|
*OutPathList = std::move(Parms.OutPathList);
|
|
|
|
}
|
|
|
|
|
|
// Function AssetRegistry.AssetRegistry.GetAllAssets
|
|
// (Native, Public, HasOutParams, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// TArray<struct FAssetData> OutAssetData (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
|
|
// bool bIncludeOnlyOnDiskAssets (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool IAssetRegistry::GetAllAssets(TArray<struct FAssetData>* OutAssetData, bool bIncludeOnlyOnDiskAssets)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AssetRegistry", "GetAllAssets");
|
|
|
|
Params::IAssetRegistry_GetAllAssets_Params Parms{};
|
|
|
|
Parms.bIncludeOnlyOnDiskAssets = bIncludeOnlyOnDiskAssets;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutAssetData != nullptr)
|
|
*OutAssetData = std::move(Parms.OutAssetData);
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AssetRegistry.AssetRegistryImpl
|
|
// (None)
|
|
|
|
class UClass* UAssetRegistryImpl::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AssetRegistryImpl");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AssetRegistryImpl AssetRegistry.Default__AssetRegistryImpl
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAssetRegistryImpl* UAssetRegistryImpl::GetDefaultObj()
|
|
{
|
|
static class UAssetRegistryImpl* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAssetRegistryImpl*>(UAssetRegistryImpl::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
}
|
|
|
|
|