hejtmy/f0re5t-main
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adds DLSS

Browse Source
This commit is contained in:
Lukáš Hejtmánek
2023-07-28 15:59:05 +02:00
parent a97fa10afc
commit f17718b9a8
194 changed files with 16931 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSSBlueprint/DLSSBlueprint.init.gen.cpp Normal file
View File

@@ -0,0 +1,35 @@
// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "UObject/GeneratedCppIncludes.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeDLSSBlueprint_init() {}
UPackage* Z_Construct_UPackage__Script_DLSSBlueprint()
{
static UPackage* ReturnPackage = nullptr;
if (!ReturnPackage)
{
static const UE4CodeGen_Private::FPackageParams PackageParams = {
"/Script/DLSSBlueprint",
nullptr,
0,
PKG_CompiledIn | 0x00000000,
0x5BF71342,
0xB82B9392,
METADATA_PARAMS(nullptr, 0)
};
UE4CodeGen_Private::ConstructUPackage(ReturnPackage, PackageParams);
}
return ReturnPackage;
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif

10
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSSBlueprint/DLSSBlueprintClasses.h Normal file
View File

@@ -0,0 +1,10 @@
// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#pragma once

981
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSSBlueprint/DLSSLibrary.gen.cpp Normal file
View File

@@ -0,0 +1,981 @@
// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "UObject/GeneratedCppIncludes.h"
#include "DLSSBlueprint/Public/DLSSLibrary.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeDLSSLibrary() {}
// Cross Module References
DLSSBLUEPRINT_API UEnum* Z_Construct_UEnum_DLSSBlueprint_UDLSSMode();
UPackage* Z_Construct_UPackage__Script_DLSSBlueprint();
DLSSBLUEPRINT_API UEnum* Z_Construct_UEnum_DLSSBlueprint_UDLSSSupport();
DLSSBLUEPRINT_API UClass* Z_Construct_UClass_UDLSSLibrary_NoRegister();
DLSSBLUEPRINT_API UClass* Z_Construct_UClass_UDLSSLibrary();
ENGINE_API UClass* Z_Construct_UClass_UBlueprintFunctionLibrary();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector2D();
// End Cross Module References
static UEnum* UDLSSMode_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, Z_Construct_UPackage__Script_DLSSBlueprint(), TEXT("UDLSSMode"));
}
return Singleton;
}
template<> DLSSBLUEPRINT_API UEnum* StaticEnum<UDLSSMode>()
{
return UDLSSMode_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_UDLSSMode(UDLSSMode_StaticEnum, TEXT("/Script/DLSSBlueprint"), TEXT("UDLSSMode"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_DLSSBlueprint_UDLSSMode_Hash() { return 178843669U; }
UEnum* Z_Construct_UEnum_DLSSBlueprint_UDLSSMode()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_DLSSBlueprint();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("UDLSSMode"), 0, Get_Z_Construct_UEnum_DLSSBlueprint_UDLSSMode_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "UDLSSMode::Off", (int64)UDLSSMode::Off },
{ "UDLSSMode::Auto", (int64)UDLSSMode::Auto },
{ "UDLSSMode::UltraQuality", (int64)UDLSSMode::UltraQuality },
{ "UDLSSMode::Quality", (int64)UDLSSMode::Quality },
{ "UDLSSMode::Balanced", (int64)UDLSSMode::Balanced },
{ "UDLSSMode::Performance", (int64)UDLSSMode::Performance },
{ "UDLSSMode::UltraPerformance", (int64)UDLSSMode::UltraPerformance },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "Auto.DisplayName", "Auto" },
{ "Auto.Name", "UDLSSMode::Auto" },
{ "Balanced.DisplayName", "Balanced" },
{ "Balanced.Name", "UDLSSMode::Balanced" },
{ "BlueprintType", "true" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "Off.DisplayName", "Off" },
{ "Off.Name", "UDLSSMode::Off" },
{ "Performance.DisplayName", "Performance" },
{ "Performance.Name", "UDLSSMode::Performance" },
{ "Quality.DisplayName", "Quality" },
{ "Quality.Name", "UDLSSMode::Quality" },
{ "UltraPerformance.DisplayName", "Ultra Performance" },
{ "UltraPerformance.Name", "UDLSSMode::UltraPerformance" },
{ "UltraQuality.DisplayName", "Ultra Quality" },
{ "UltraQuality.Name", "UDLSSMode::UltraQuality" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_DLSSBlueprint,
nullptr,
"UDLSSMode",
"UDLSSMode",
Enumerators,
UE_ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
EEnumFlags::None,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* UDLSSSupport_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_DLSSBlueprint_UDLSSSupport, Z_Construct_UPackage__Script_DLSSBlueprint(), TEXT("UDLSSSupport"));
}
return Singleton;
}
template<> DLSSBLUEPRINT_API UEnum* StaticEnum<UDLSSSupport>()
{
return UDLSSSupport_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_UDLSSSupport(UDLSSSupport_StaticEnum, TEXT("/Script/DLSSBlueprint"), TEXT("UDLSSSupport"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_DLSSBlueprint_UDLSSSupport_Hash() { return 1521584805U; }
UEnum* Z_Construct_UEnum_DLSSBlueprint_UDLSSSupport()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_DLSSBlueprint();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("UDLSSSupport"), 0, Get_Z_Construct_UEnum_DLSSBlueprint_UDLSSSupport_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "UDLSSSupport::Supported", (int64)UDLSSSupport::Supported },
{ "UDLSSSupport::NotSupported", (int64)UDLSSSupport::NotSupported },
{ "UDLSSSupport::NotSupportedIncompatibleHardware", (int64)UDLSSSupport::NotSupportedIncompatibleHardware },
{ "UDLSSSupport::NotSupportedDriverOutOfDate", (int64)UDLSSSupport::NotSupportedDriverOutOfDate },
{ "UDLSSSupport::NotSupportedOperatingSystemOutOfDate", (int64)UDLSSSupport::NotSupportedOperatingSystemOutOfDate },
{ "UDLSSSupport::NotSupportedByPlatformAtBuildTime", (int64)UDLSSSupport::NotSupportedByPlatformAtBuildTime },
{ "UDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive", (int64)UDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "NotSupported.DisplayName", "Not Supported" },
{ "NotSupported.Name", "UDLSSSupport::NotSupported" },
{ "NotSupportedByPlatformAtBuildTime.DisplayName", "Platform Not Supported At Build Time" },
{ "NotSupportedByPlatformAtBuildTime.Name", "UDLSSSupport::NotSupportedByPlatformAtBuildTime" },
{ "NotSupportedByPlatformAtBuildTime.ToolTip", "This platform doesn't not support DLSS at build time. Currently DLSS is only supported on Windows 64" },
{ "NotSupportedDriverOutOfDate.DisplayName", "Driver Out of Date" },
{ "NotSupportedDriverOutOfDate.Name", "UDLSSSupport::NotSupportedDriverOutOfDate" },
{ "NotSupportedDriverOutOfDate.ToolTip", "The driver is outdated. Also see GetDLSSMinimumDriverVersion" },
{ "NotSupportedIncompatibleAPICaptureToolActive.DisplayName", "Incompatible API Capture Tool Active" },
{ "NotSupportedIncompatibleAPICaptureToolActive.Name", "UDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive" },
{ "NotSupportedIncompatibleAPICaptureToolActive.ToolTip", "DLSS is not compatible with an active API capture tool such as RenderDoc." },
{ "NotSupportedIncompatibleHardware.DisplayName", "Incompatible Hardware" },
{ "NotSupportedIncompatibleHardware.Name", "UDLSSSupport::NotSupportedIncompatibleHardware" },
{ "NotSupportedIncompatibleHardware.ToolTip", "DLSS requires an NVIDIA RTX GPU" },
{ "NotSupportedOperatingSystemOutOfDate.DisplayName", "Operating System Out of Date" },
{ "NotSupportedOperatingSystemOutOfDate.Name", "UDLSSSupport::NotSupportedOperatingSystemOutOfDate" },
{ "NotSupportedOperatingSystemOutOfDate.ToolTip", "DLSS requires at least Windows 10 Fall 2017 Creators Update 64-bit, (v1709, build 16299)" },
{ "Supported.DisplayName", "Supported" },
{ "Supported.Name", "UDLSSSupport::Supported" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_DLSSBlueprint,
nullptr,
"UDLSSSupport",
"UDLSSSupport",
Enumerators,
UE_ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
EEnumFlags::None,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetDefaultDLSSMode)
{
P_FINISH;
P_NATIVE_BEGIN;
*(UDLSSMode*)Z_Param__Result=UDLSSLibrary::GetDefaultDLSSMode();
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetDLSSSharpness)
{
P_FINISH;
P_NATIVE_BEGIN;
*(float*)Z_Param__Result=UDLSSLibrary::GetDLSSSharpness();
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execSetDLSSSharpness)
{
P_GET_PROPERTY(FFloatProperty,Z_Param_Sharpness);
P_FINISH;
P_NATIVE_BEGIN;
UDLSSLibrary::SetDLSSSharpness(Z_Param_Sharpness);
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetDLSSMode)
{
P_FINISH;
P_NATIVE_BEGIN;
*(UDLSSMode*)Z_Param__Result=UDLSSLibrary::GetDLSSMode();
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execSetDLSSMode)
{
P_GET_ENUM(UDLSSMode,Z_Param_DLSSMode);
P_FINISH;
P_NATIVE_BEGIN;
UDLSSLibrary::SetDLSSMode(UDLSSMode(Z_Param_DLSSMode));
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetDLSSScreenPercentageRange)
{
P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_MinScreenPercentage);
P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_MaxScreenPercentage);
P_FINISH;
P_NATIVE_BEGIN;
UDLSSLibrary::GetDLSSScreenPercentageRange(Z_Param_Out_MinScreenPercentage,Z_Param_Out_MaxScreenPercentage);
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetDLSSModeInformation)
{
P_GET_ENUM(UDLSSMode,Z_Param_DLSSMode);
P_GET_STRUCT(FVector2D,Z_Param_ScreenResolution);
P_GET_UBOOL_REF(Z_Param_Out_bIsSupported);
P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_OptimalScreenPercentage);
P_GET_UBOOL_REF(Z_Param_Out_bIsFixedScreenPercentage);
P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_MinScreenPercentage);
P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_MaxScreenPercentage);
P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_OptimalSharpness);
P_FINISH;
P_NATIVE_BEGIN;
UDLSSLibrary::GetDLSSModeInformation(UDLSSMode(Z_Param_DLSSMode),Z_Param_ScreenResolution,Z_Param_Out_bIsSupported,Z_Param_Out_OptimalScreenPercentage,Z_Param_Out_bIsFixedScreenPercentage,Z_Param_Out_MinScreenPercentage,Z_Param_Out_MaxScreenPercentage,Z_Param_Out_OptimalSharpness);
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetSupportedDLSSModes)
{
P_FINISH;
P_NATIVE_BEGIN;
*(TArray<UDLSSMode>*)Z_Param__Result=UDLSSLibrary::GetSupportedDLSSModes();
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execIsDLSSModeSupported)
{
P_GET_ENUM(UDLSSMode,Z_Param_DLSSMode);
P_FINISH;
P_NATIVE_BEGIN;
*(bool*)Z_Param__Result=UDLSSLibrary::IsDLSSModeSupported(UDLSSMode(Z_Param_DLSSMode));
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execIsDLAAEnabled)
{
P_FINISH;
P_NATIVE_BEGIN;
*(bool*)Z_Param__Result=UDLSSLibrary::IsDLAAEnabled();
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execEnableDLAA)
{
P_GET_UBOOL(Z_Param_bEnabled);
P_FINISH;
P_NATIVE_BEGIN;
UDLSSLibrary::EnableDLAA(Z_Param_bEnabled);
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execGetDLSSMinimumDriverVersion)
{
P_GET_PROPERTY_REF(FIntProperty,Z_Param_Out_MinDriverVersionMajor);
P_GET_PROPERTY_REF(FIntProperty,Z_Param_Out_MinDriverVersionMinor);
P_FINISH;
P_NATIVE_BEGIN;
UDLSSLibrary::GetDLSSMinimumDriverVersion(Z_Param_Out_MinDriverVersionMajor,Z_Param_Out_MinDriverVersionMinor);
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execQueryDLSSSupport)
{
P_FINISH;
P_NATIVE_BEGIN;
*(UDLSSSupport*)Z_Param__Result=UDLSSLibrary::QueryDLSSSupport();
P_NATIVE_END;
}
DEFINE_FUNCTION(UDLSSLibrary::execIsDLSSSupported)
{
P_FINISH;
P_NATIVE_BEGIN;
*(bool*)Z_Param__Result=UDLSSLibrary::IsDLSSSupported();
P_NATIVE_END;
}
void UDLSSLibrary::StaticRegisterNativesUDLSSLibrary()
{
UClass* Class = UDLSSLibrary::StaticClass();
static const FNameNativePtrPair Funcs[] = {
{ "EnableDLAA", &UDLSSLibrary::execEnableDLAA },
{ "GetDefaultDLSSMode", &UDLSSLibrary::execGetDefaultDLSSMode },
{ "GetDLSSMinimumDriverVersion", &UDLSSLibrary::execGetDLSSMinimumDriverVersion },
{ "GetDLSSMode", &UDLSSLibrary::execGetDLSSMode },
{ "GetDLSSModeInformation", &UDLSSLibrary::execGetDLSSModeInformation },
{ "GetDLSSScreenPercentageRange", &UDLSSLibrary::execGetDLSSScreenPercentageRange },
{ "GetDLSSSharpness", &UDLSSLibrary::execGetDLSSSharpness },
{ "GetSupportedDLSSModes", &UDLSSLibrary::execGetSupportedDLSSModes },
{ "IsDLAAEnabled", &UDLSSLibrary::execIsDLAAEnabled },
{ "IsDLSSModeSupported", &UDLSSLibrary::execIsDLSSModeSupported },
{ "IsDLSSSupported", &UDLSSLibrary::execIsDLSSSupported },
{ "QueryDLSSSupport", &UDLSSLibrary::execQueryDLSSSupport },
{ "SetDLSSMode", &UDLSSLibrary::execSetDLSSMode },
{ "SetDLSSSharpness", &UDLSSLibrary::execSetDLSSSharpness },
};
FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, UE_ARRAY_COUNT(Funcs));
}
struct Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics
{
struct DLSSLibrary_eventEnableDLAA_Parms
{
bool bEnabled;
};
static void NewProp_bEnabled_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnabled;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::NewProp_bEnabled_SetBit(void* Obj)
{
((DLSSLibrary_eventEnableDLAA_Parms*)Obj)->bEnabled = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::NewProp_bEnabled = { "bEnabled", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(DLSSLibrary_eventEnableDLAA_Parms), &Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::NewProp_bEnabled_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::NewProp_bEnabled,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Enable/disable DLAA. Note that while DLAA is enabled, DLSS will be automatically disabled */" },
{ "DisplayName", "Enable DLAA" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Enable/disable DLAA. Note that while DLAA is enabled, DLSS will be automatically disabled" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "EnableDLAA", nullptr, nullptr, sizeof(DLSSLibrary_eventEnableDLAA_Parms), Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_EnableDLAA()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_EnableDLAA_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics
{
struct DLSSLibrary_eventGetDefaultDLSSMode_Parms
{
UDLSSMode ReturnValue;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDefaultDLSSMode_Parms, ReturnValue), Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::NewProp_ReturnValue_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/* Find a reasonable default DLSS mode based on current hardware */" },
{ "DisplayName", "Get Default DLSS Mode" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Find a reasonable default DLSS mode based on current hardware" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetDefaultDLSSMode", nullptr, nullptr, sizeof(DLSSLibrary_eventGetDefaultDLSSMode_Parms), Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics
{
struct DLSSLibrary_eventGetDLSSMinimumDriverVersion_Parms
{
int32 MinDriverVersionMajor;
int32 MinDriverVersionMinor;
};
static const UE4CodeGen_Private::FIntPropertyParams NewProp_MinDriverVersionMajor;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_MinDriverVersionMinor;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::NewProp_MinDriverVersionMajor = { "MinDriverVersionMajor", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSMinimumDriverVersion_Parms, MinDriverVersionMajor), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::NewProp_MinDriverVersionMinor = { "MinDriverVersionMinor", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSMinimumDriverVersion_Parms, MinDriverVersionMinor), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::NewProp_MinDriverVersionMajor,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::NewProp_MinDriverVersionMinor,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** If QueryDLSSSupport returns \"NotSupportedDriverOutOfDate\", then MinDriverVersionMajor and MinDriverVersionMinor contains the required driver version.*/" },
{ "DisplayName", "Get DLSS Minimum DriverVersion" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "If QueryDLSSSupport returns \"NotSupportedDriverOutOfDate\", then MinDriverVersionMajor and MinDriverVersionMinor contains the required driver version." },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetDLSSMinimumDriverVersion", nullptr, nullptr, sizeof(DLSSLibrary_eventGetDLSSMinimumDriverVersion_Parms), Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14422403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics
{
struct DLSSLibrary_eventGetDLSSMode_Parms
{
UDLSSMode ReturnValue;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSMode_Parms, ReturnValue), Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::NewProp_ReturnValue_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/* Reads the console variables to infer the current DLSS mode (r.NGX.DLSS.Enable, r.NGX.DLSS.Quality, r.TemporalAA.Upscaler)*/" },
{ "DisplayName", "Get DLSS Mode" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Reads the console variables to infer the current DLSS mode (r.NGX.DLSS.Enable, r.NGX.DLSS.Quality, r.TemporalAA.Upscaler)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetDLSSMode", nullptr, nullptr, sizeof(DLSSLibrary_eventGetDLSSMode_Parms), Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics
{
struct DLSSLibrary_eventGetDLSSModeInformation_Parms
{
UDLSSMode DLSSMode;
FVector2D ScreenResolution;
bool bIsSupported;
float OptimalScreenPercentage;
bool bIsFixedScreenPercentage;
float MinScreenPercentage;
float MaxScreenPercentage;
float OptimalSharpness;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_DLSSMode_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DLSSMode;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_ScreenResolution;
static void NewProp_bIsSupported_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bIsSupported;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_OptimalScreenPercentage;
static void NewProp_bIsFixedScreenPercentage_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bIsFixedScreenPercentage;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MinScreenPercentage;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MaxScreenPercentage;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_OptimalSharpness;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_DLSSMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_DLSSMode = { "DLSSMode", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSModeInformation_Parms, DLSSMode), Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_ScreenResolution = { "ScreenResolution", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSModeInformation_Parms, ScreenResolution), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsSupported_SetBit(void* Obj)
{
((DLSSLibrary_eventGetDLSSModeInformation_Parms*)Obj)->bIsSupported = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsSupported = { "bIsSupported", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(DLSSLibrary_eventGetDLSSModeInformation_Parms), &Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsSupported_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_OptimalScreenPercentage = { "OptimalScreenPercentage", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSModeInformation_Parms, OptimalScreenPercentage), METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsFixedScreenPercentage_SetBit(void* Obj)
{
((DLSSLibrary_eventGetDLSSModeInformation_Parms*)Obj)->bIsFixedScreenPercentage = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsFixedScreenPercentage = { "bIsFixedScreenPercentage", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(DLSSLibrary_eventGetDLSSModeInformation_Parms), &Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsFixedScreenPercentage_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_MinScreenPercentage = { "MinScreenPercentage", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSModeInformation_Parms, MinScreenPercentage), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_MaxScreenPercentage = { "MaxScreenPercentage", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSModeInformation_Parms, MaxScreenPercentage), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_OptimalSharpness = { "OptimalSharpness", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSModeInformation_Parms, OptimalSharpness), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_DLSSMode_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_DLSSMode,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_ScreenResolution,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsSupported,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_OptimalScreenPercentage,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_bIsFixedScreenPercentage,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_MinScreenPercentage,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_MaxScreenPercentage,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::NewProp_OptimalSharpness,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Provides additional details (such as screen percentage ranges) about a DLSS mode. Screen Resolution is required for Auto mode */" },
{ "DisplayName", "Get DLSS Mode Information" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Provides additional details (such as screen percentage ranges) about a DLSS mode. Screen Resolution is required for Auto mode" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetDLSSModeInformation", nullptr, nullptr, sizeof(DLSSLibrary_eventGetDLSSModeInformation_Parms), Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics
{
struct DLSSLibrary_eventGetDLSSScreenPercentageRange_Parms
{
float MinScreenPercentage;
float MaxScreenPercentage;
};
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MinScreenPercentage;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_MaxScreenPercentage;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::NewProp_MinScreenPercentage = { "MinScreenPercentage", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSScreenPercentageRange_Parms, MinScreenPercentage), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::NewProp_MaxScreenPercentage = { "MaxScreenPercentage", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSScreenPercentageRange_Parms, MaxScreenPercentage), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::NewProp_MinScreenPercentage,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::NewProp_MaxScreenPercentage,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** The global screen percentage range that DLSS supports. Excludes DLSS modes with fixed screen percentage. Also see GetDLSSModeInformation*/" },
{ "DisplayName", "Get DLSS Screenpercentage Range" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "The global screen percentage range that DLSS supports. Excludes DLSS modes with fixed screen percentage. Also see GetDLSSModeInformation" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetDLSSScreenPercentageRange", nullptr, nullptr, sizeof(DLSSLibrary_eventGetDLSSScreenPercentageRange_Parms), Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14422403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics
{
struct DLSSLibrary_eventGetDLSSSharpness_Parms
{
float ReturnValue;
};
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetDLSSSharpness_Parms, ReturnValue), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/*Reads the console variables to infer the current DLSS sharpness (r.NGX.DLSS.Sharpness) */" },
{ "DisplayName", "Get DLSS Sharpness" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Reads the console variables to infer the current DLSS sharpness (r.NGX.DLSS.Sharpness)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetDLSSSharpness", nullptr, nullptr, sizeof(DLSSLibrary_eventGetDLSSSharpness_Parms), Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics
{
struct DLSSLibrary_eventGetSupportedDLSSModes_Parms
{
TArray<UDLSSMode> ReturnValue;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Inner_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue_Inner;
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::NewProp_ReturnValue_Inner_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::NewProp_ReturnValue_Inner = { "ReturnValue", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventGetSupportedDLSSModes_Parms, ReturnValue), EArrayPropertyFlags::None, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::NewProp_ReturnValue_Inner_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::NewProp_ReturnValue_Inner,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Retrieves all supported DLSS modes. Can be used to populate UI */" },
{ "DisplayName", "Get Supported DLSS Modes" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Retrieves all supported DLSS modes. Can be used to populate UI" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "GetSupportedDLSSModes", nullptr, nullptr, sizeof(DLSSLibrary_eventGetSupportedDLSSModes_Parms), Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics
{
struct DLSSLibrary_eventIsDLAAEnabled_Parms
{
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((DLSSLibrary_eventIsDLAAEnabled_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(DLSSLibrary_eventIsDLAAEnabled_Parms), &Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Checks whether DLAA is enabled */" },
{ "DisplayName", "Is DLAA Enabled" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Checks whether DLAA is enabled" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "IsDLAAEnabled", nullptr, nullptr, sizeof(DLSSLibrary_eventIsDLAAEnabled_Parms), Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics
{
struct DLSSLibrary_eventIsDLSSModeSupported_Parms
{
UDLSSMode DLSSMode;
bool ReturnValue;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_DLSSMode_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DLSSMode;
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_DLSSMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_DLSSMode = { "DLSSMode", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventIsDLSSModeSupported_Parms, DLSSMode), Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((DLSSLibrary_eventIsDLSSModeSupported_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(DLSSLibrary_eventIsDLSSModeSupported_Parms), &Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_DLSSMode_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_DLSSMode,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Checks whether a DLSS mode is supported */" },
{ "DisplayName", "Is DLSS Mode Supported" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Checks whether a DLSS mode is supported" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "IsDLSSModeSupported", nullptr, nullptr, sizeof(DLSSLibrary_eventIsDLSSModeSupported_Parms), Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics
{
struct DLSSLibrary_eventIsDLSSSupported_Parms
{
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((DLSSLibrary_eventIsDLSSSupported_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(DLSSLibrary_eventIsDLSSSupported_Parms), &Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Checks whether DLSS/DLAA is supported by the current GPU. Further details can be retrieved via QueryDLSSSupport*/" },
{ "DisplayName", "Is NVIDIA DLSS Supported" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Checks whether DLSS/DLAA is supported by the current GPU. Further details can be retrieved via QueryDLSSSupport" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "IsDLSSSupported", nullptr, nullptr, sizeof(DLSSLibrary_eventIsDLSSSupported_Parms), Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics
{
struct DLSSLibrary_eventQueryDLSSSupport_Parms
{
UDLSSSupport ReturnValue;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventQueryDLSSSupport_Parms, ReturnValue), Z_Construct_UEnum_DLSSBlueprint_UDLSSSupport, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::NewProp_ReturnValue_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Checks whether DLSS/DLAA is supported by the current GPU\x09*/" },
{ "DisplayName", "Query NVIDIA DLSS Support" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Checks whether DLSS/DLAA is supported by the current GPU" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "QueryDLSSSupport", nullptr, nullptr, sizeof(DLSSLibrary_eventQueryDLSSSupport_Parms), Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics
{
struct DLSSLibrary_eventSetDLSSMode_Parms
{
UDLSSMode DLSSMode;
};
static const UE4CodeGen_Private::FBytePropertyParams NewProp_DLSSMode_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DLSSMode;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::NewProp_DLSSMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::NewProp_DLSSMode = { "DLSSMode", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventSetDLSSMode_Parms, DLSSMode), Z_Construct_UEnum_DLSSBlueprint_UDLSSMode, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::NewProp_DLSSMode_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::NewProp_DLSSMode,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/** Sets the console variables to enable/disable DLSS (r.NGX.DLSS.Enable, r.NGX.DLSS.Quality)*/" },
{ "DisplayName", "Set DLSS Mode" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Sets the console variables to enable/disable DLSS (r.NGX.DLSS.Enable, r.NGX.DLSS.Quality)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "SetDLSSMode", nullptr, nullptr, sizeof(DLSSLibrary_eventSetDLSSMode_Parms), Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics
{
struct DLSSLibrary_eventSetDLSSSharpness_Parms
{
float Sharpness;
};
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_Sharpness;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::NewProp_Sharpness = { "Sharpness", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(DLSSLibrary_eventSetDLSSSharpness_Parms, Sharpness), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::NewProp_Sharpness,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::Function_MetaDataParams[] = {
{ "Category", "DLSS" },
{ "Comment", "/* Sets the console variables to enable additional DLSS sharpening. Set to 0 to disable (r.NGX.DLSS.Sharpness) */" },
{ "DisplayName", "Set DLSS Sharpness" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
{ "ToolTip", "Sets the console variables to enable additional DLSS sharpening. Set to 0 to disable (r.NGX.DLSS.Sharpness)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UDLSSLibrary, nullptr, "SetDLSSSharpness", nullptr, nullptr, sizeof(DLSSLibrary_eventSetDLSSSharpness_Parms), Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022403, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness_Statics::FuncParams);
}
return ReturnFunction;
}
UClass* Z_Construct_UClass_UDLSSLibrary_NoRegister()
{
return UDLSSLibrary::StaticClass();
}
struct Z_Construct_UClass_UDLSSLibrary_Statics
{
static UObject* (*const DependentSingletons[])();
static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UDLSSLibrary_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_UBlueprintFunctionLibrary,
(UObject* (*)())Z_Construct_UPackage__Script_DLSSBlueprint,
};
const FClassFunctionLinkInfo Z_Construct_UClass_UDLSSLibrary_Statics::FuncInfo[] = {
{ &Z_Construct_UFunction_UDLSSLibrary_EnableDLAA, "EnableDLAA" }, // 911162253
{ &Z_Construct_UFunction_UDLSSLibrary_GetDefaultDLSSMode, "GetDefaultDLSSMode" }, // 578967396
{ &Z_Construct_UFunction_UDLSSLibrary_GetDLSSMinimumDriverVersion, "GetDLSSMinimumDriverVersion" }, // 1556264258
{ &Z_Construct_UFunction_UDLSSLibrary_GetDLSSMode, "GetDLSSMode" }, // 2511064192
{ &Z_Construct_UFunction_UDLSSLibrary_GetDLSSModeInformation, "GetDLSSModeInformation" }, // 1087274364
{ &Z_Construct_UFunction_UDLSSLibrary_GetDLSSScreenPercentageRange, "GetDLSSScreenPercentageRange" }, // 1690551544
{ &Z_Construct_UFunction_UDLSSLibrary_GetDLSSSharpness, "GetDLSSSharpness" }, // 637941015
{ &Z_Construct_UFunction_UDLSSLibrary_GetSupportedDLSSModes, "GetSupportedDLSSModes" }, // 42367125
{ &Z_Construct_UFunction_UDLSSLibrary_IsDLAAEnabled, "IsDLAAEnabled" }, // 16617166
{ &Z_Construct_UFunction_UDLSSLibrary_IsDLSSModeSupported, "IsDLSSModeSupported" }, // 1538485074
{ &Z_Construct_UFunction_UDLSSLibrary_IsDLSSSupported, "IsDLSSSupported" }, // 1852524390
{ &Z_Construct_UFunction_UDLSSLibrary_QueryDLSSSupport, "QueryDLSSSupport" }, // 227199299
{ &Z_Construct_UFunction_UDLSSLibrary_SetDLSSMode, "SetDLSSMode" }, // 820694163
{ &Z_Construct_UFunction_UDLSSLibrary_SetDLSSSharpness, "SetDLSSSharpness" }, // 1286679746
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSLibrary_Statics::Class_MetaDataParams[] = {
{ "IncludePath", "DLSSLibrary.h" },
{ "ModuleRelativePath", "Public/DLSSLibrary.h" },
};
#endif
const FCppClassTypeInfoStatic Z_Construct_UClass_UDLSSLibrary_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<UDLSSLibrary>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UDLSSLibrary_Statics::ClassParams = {
&UDLSSLibrary::StaticClass,
nullptr,
&StaticCppClassTypeInfo,
DependentSingletons,
FuncInfo,
nullptr,
nullptr,
UE_ARRAY_COUNT(DependentSingletons),
UE_ARRAY_COUNT(FuncInfo),
0,
0,
0x000800A0u,
METADATA_PARAMS(Z_Construct_UClass_UDLSSLibrary_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSLibrary_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_UDLSSLibrary()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UDLSSLibrary_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(UDLSSLibrary, 133521508);
template<> DLSSBLUEPRINT_API UClass* StaticClass<UDLSSLibrary>()
{
return UDLSSLibrary::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_UDLSSLibrary(Z_Construct_UClass_UDLSSLibrary, &UDLSSLibrary::StaticClass, TEXT("/Script/DLSSBlueprint"), TEXT("UDLSSLibrary"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(UDLSSLibrary);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif

156
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSSBlueprint/DLSSLibrary.generated.h Normal file
View File

@@ -0,0 +1,156 @@
// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
enum class UDLSSMode : uint8;
struct FVector2D;
enum class UDLSSSupport : uint8;
#ifdef DLSSBLUEPRINT_DLSSLibrary_generated_h
#error "DLSSLibrary.generated.h already included, missing '#pragma once' in DLSSLibrary.h"
#endif
#define DLSSBLUEPRINT_DLSSLibrary_generated_h
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_SPARSE_DATA
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_RPC_WRAPPERS \
\
DECLARE_FUNCTION(execGetDefaultDLSSMode); \
DECLARE_FUNCTION(execGetDLSSSharpness); \
DECLARE_FUNCTION(execSetDLSSSharpness); \
DECLARE_FUNCTION(execGetDLSSMode); \
DECLARE_FUNCTION(execSetDLSSMode); \
DECLARE_FUNCTION(execGetDLSSScreenPercentageRange); \
DECLARE_FUNCTION(execGetDLSSModeInformation); \
DECLARE_FUNCTION(execGetSupportedDLSSModes); \
DECLARE_FUNCTION(execIsDLSSModeSupported); \
DECLARE_FUNCTION(execIsDLAAEnabled); \
DECLARE_FUNCTION(execEnableDLAA); \
DECLARE_FUNCTION(execGetDLSSMinimumDriverVersion); \
DECLARE_FUNCTION(execQueryDLSSSupport); \
DECLARE_FUNCTION(execIsDLSSSupported);
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_RPC_WRAPPERS_NO_PURE_DECLS \
\
DECLARE_FUNCTION(execGetDefaultDLSSMode); \
DECLARE_FUNCTION(execGetDLSSSharpness); \
DECLARE_FUNCTION(execSetDLSSSharpness); \
DECLARE_FUNCTION(execGetDLSSMode); \
DECLARE_FUNCTION(execSetDLSSMode); \
DECLARE_FUNCTION(execGetDLSSScreenPercentageRange); \
DECLARE_FUNCTION(execGetDLSSModeInformation); \
DECLARE_FUNCTION(execGetSupportedDLSSModes); \
DECLARE_FUNCTION(execIsDLSSModeSupported); \
DECLARE_FUNCTION(execIsDLAAEnabled); \
DECLARE_FUNCTION(execEnableDLAA); \
DECLARE_FUNCTION(execGetDLSSMinimumDriverVersion); \
DECLARE_FUNCTION(execQueryDLSSSupport); \
DECLARE_FUNCTION(execIsDLSSSupported);
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_INCLASS_NO_PURE_DECLS \
private: \
static void StaticRegisterNativesUDLSSLibrary(); \
friend struct Z_Construct_UClass_UDLSSLibrary_Statics; \
public: \
DECLARE_CLASS(UDLSSLibrary, UBlueprintFunctionLibrary, COMPILED_IN_FLAGS(0), CASTCLASS_None, TEXT("/Script/DLSSBlueprint"), DLSSBLUEPRINT_API) \
DECLARE_SERIALIZER(UDLSSLibrary)
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_INCLASS \
private: \
static void StaticRegisterNativesUDLSSLibrary(); \
friend struct Z_Construct_UClass_UDLSSLibrary_Statics; \
public: \
DECLARE_CLASS(UDLSSLibrary, UBlueprintFunctionLibrary, COMPILED_IN_FLAGS(0), CASTCLASS_None, TEXT("/Script/DLSSBlueprint"), DLSSBLUEPRINT_API) \
DECLARE_SERIALIZER(UDLSSLibrary)
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_STANDARD_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
DLSSBLUEPRINT_API UDLSSLibrary(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(UDLSSLibrary) \
DECLARE_VTABLE_PTR_HELPER_CTOR(DLSSBLUEPRINT_API, UDLSSLibrary); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(UDLSSLibrary); \
private: \
/** Private move- and copy-constructors, should never be used */ \
DLSSBLUEPRINT_API UDLSSLibrary(UDLSSLibrary&&); \
DLSSBLUEPRINT_API UDLSSLibrary(const UDLSSLibrary&); \
public:
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_ENHANCED_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
DLSSBLUEPRINT_API UDLSSLibrary(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \
private: \
/** Private move- and copy-constructors, should never be used */ \
DLSSBLUEPRINT_API UDLSSLibrary(UDLSSLibrary&&); \
DLSSBLUEPRINT_API UDLSSLibrary(const UDLSSLibrary&); \
public: \
DECLARE_VTABLE_PTR_HELPER_CTOR(DLSSBLUEPRINT_API, UDLSSLibrary); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(UDLSSLibrary); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(UDLSSLibrary)
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_PRIVATE_PROPERTY_OFFSET
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_64_PROLOG
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_GENERATED_BODY_LEGACY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_PRIVATE_PROPERTY_OFFSET \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_SPARSE_DATA \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_RPC_WRAPPERS \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_INCLASS \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_STANDARD_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#define f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_PRIVATE_PROPERTY_OFFSET \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_SPARSE_DATA \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_RPC_WRAPPERS_NO_PURE_DECLS \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_INCLASS_NO_PURE_DECLS \
f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h_68_ENHANCED_CONSTRUCTORS \
private: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
template<> DLSSBLUEPRINT_API UClass* StaticClass<class UDLSSLibrary>();
#undef CURRENT_FILE_ID
#define CURRENT_FILE_ID f0re5t_main_Plugins_DLSS_Source_DLSSBlueprint_Public_DLSSLibrary_h
#define FOREACH_ENUM_UDLSSMODE(op) \
op(UDLSSMode::Off) \
op(UDLSSMode::Auto) \
op(UDLSSMode::UltraQuality) \
op(UDLSSMode::Quality) \
op(UDLSSMode::Balanced) \
op(UDLSSMode::Performance) \
op(UDLSSMode::UltraPerformance)
enum class UDLSSMode : uint8;
template<> DLSSBLUEPRINT_API UEnum* StaticEnum<UDLSSMode>();
#define FOREACH_ENUM_UDLSSSUPPORT(op) \
op(UDLSSSupport::Supported) \
op(UDLSSSupport::NotSupported) \
op(UDLSSSupport::NotSupportedIncompatibleHardware) \
op(UDLSSSupport::NotSupportedDriverOutOfDate) \
op(UDLSSSupport::NotSupportedOperatingSystemOutOfDate) \
op(UDLSSSupport::NotSupportedByPlatformAtBuildTime) \
op(UDLSSSupport::NotSupportedIncompatibleAPICaptureToolActive)
enum class UDLSSSupport : uint8;
template<> DLSSBLUEPRINT_API UEnum* StaticEnum<UDLSSSupport>();
PRAGMA_ENABLE_DEPRECATION_WARNINGS

1
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSSBlueprint/Timestamp Normal file
View File

@@ -0,0 +1 @@
D:\Projects\CZU\f0re5t-main\Plugins\DLSS\Source\DLSSBlueprint\Public\DLSSLibrary.h