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/DLSS/DLSS.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 EmptyLinkFunctionForGeneratedCodeDLSS_init() {}
UPackage* Z_Construct_UPackage__Script_DLSS()
{
static UPackage* ReturnPackage = nullptr;
if (!ReturnPackage)
{
static const UE4CodeGen_Private::FPackageParams PackageParams = {
"/Script/DLSS",
nullptr,
0,
PKG_CompiledIn | 0x00000000,
0xCD95479C,
0x0695E4C4,
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/DLSS/DLSSClasses.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

525
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSS/DLSSSettings.gen.cpp Normal file
View File

@@ -0,0 +1,525 @@
// 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 "DLSS/Public/DLSSSettings.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeDLSSSettings() {}
// Cross Module References
DLSS_API UEnum* Z_Construct_UEnum_DLSS_EDLSSSettingOverride();
UPackage* Z_Construct_UPackage__Script_DLSS();
DLSS_API UClass* Z_Construct_UClass_UDLSSOverrideSettings_NoRegister();
DLSS_API UClass* Z_Construct_UClass_UDLSSOverrideSettings();
COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
DLSS_API UClass* Z_Construct_UClass_UDLSSSettings_NoRegister();
DLSS_API UClass* Z_Construct_UClass_UDLSSSettings();
// End Cross Module References
static UEnum* EDLSSSettingOverride_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_DLSS_EDLSSSettingOverride, Z_Construct_UPackage__Script_DLSS(), TEXT("EDLSSSettingOverride"));
}
return Singleton;
}
template<> DLSS_API UEnum* StaticEnum<EDLSSSettingOverride>()
{
return EDLSSSettingOverride_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EDLSSSettingOverride(EDLSSSettingOverride_StaticEnum, TEXT("/Script/DLSS"), TEXT("EDLSSSettingOverride"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_DLSS_EDLSSSettingOverride_Hash() { return 3522351107U; }
UEnum* Z_Construct_UEnum_DLSS_EDLSSSettingOverride()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_DLSS();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EDLSSSettingOverride"), 0, Get_Z_Construct_UEnum_DLSS_EDLSSSettingOverride_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EDLSSSettingOverride::Enabled", (int64)EDLSSSettingOverride::Enabled },
{ "EDLSSSettingOverride::Disabled", (int64)EDLSSSettingOverride::Disabled },
{ "EDLSSSettingOverride::UseProjectSettings", (int64)EDLSSSettingOverride::UseProjectSettings },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "Disabled.DisplayName", "False" },
{ "Disabled.Name", "EDLSSSettingOverride::Disabled" },
{ "Enabled.DisplayName", "True" },
{ "Enabled.Name", "EDLSSSettingOverride::Enabled" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "UseProjectSettings.DisplayName", "Use project settings" },
{ "UseProjectSettings.Name", "EDLSSSettingOverride::UseProjectSettings" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_DLSS,
nullptr,
"EDLSSSettingOverride",
"EDLSSSettingOverride",
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;
}
void UDLSSOverrideSettings::StaticRegisterNativesUDLSSOverrideSettings()
{
}
UClass* Z_Construct_UClass_UDLSSOverrideSettings_NoRegister()
{
return UDLSSOverrideSettings::StaticClass();
}
struct Z_Construct_UClass_UDLSSOverrideSettings_Statics
{
static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FBytePropertyParams NewProp_EnableDLSSInEditorViewportsOverride_Underlying;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_EnableDLSSInEditorViewportsOverride_MetaData[];
#endif
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_EnableDLSSInEditorViewportsOverride;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_Underlying;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_MetaData[];
#endif
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_EnableDLSSInPlayInEditorViewportsOverride_Underlying;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_EnableDLSSInPlayInEditorViewportsOverride_MetaData[];
#endif
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_EnableDLSSInPlayInEditorViewportsOverride;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_MetaData[];
#endif
static void NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bShowDLSSIncompatiblePluginsToolsWarnings;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ShowDLSSSDebugOnScreenMessages_Underlying;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ShowDLSSSDebugOnScreenMessages_MetaData[];
#endif
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ShowDLSSSDebugOnScreenMessages;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UDLSSOverrideSettings_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_UObject,
(UObject* (*)())Z_Construct_UPackage__Script_DLSS,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSOverrideSettings_Statics::Class_MetaDataParams[] = {
{ "IncludePath", "DLSSSettings.h" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
};
#endif
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride_MetaData[] = {
{ "Category", "Level Editor - Viewport (Local)" },
{ "Comment", "/** This enables DLSS in editor viewports. Saved to local user config only.*/" },
{ "DisplayName", "Enable DLSS to be turned on in Editor viewports" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables DLSS in editor viewports. Saved to local user config only." },
};
#endif
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride = { "EnableDLSSInEditorViewportsOverride", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSOverrideSettings, EnableDLSSInEditorViewportsOverride), Z_Construct_UEnum_DLSS_EDLSSSettingOverride, METADATA_PARAMS(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride_MetaData)) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_MetaData[] = {
{ "Category", "Level Editor - Viewport (Local)" },
{ "Comment", "/** This setting enables adjusting the screenpercentage directly in the editor, outside of the optimized DLSS quality modes. Saved to local user config only.*/" },
{ "DisplayName", "Enable Screenpercentage Manipulation in DLSS Editor Viewports" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This setting enables adjusting the screenpercentage directly in the editor, outside of the optimized DLSS quality modes. Saved to local user config only." },
};
#endif
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride = { "EnableScreenpercentageManipulationInDLSSEditorViewportsOverride", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSOverrideSettings, EnableScreenpercentageManipulationInDLSSEditorViewportsOverride), Z_Construct_UEnum_DLSS_EDLSSSettingOverride, METADATA_PARAMS(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_MetaData)) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride_MetaData[] = {
{ "Category", "Level Editor - Viewport (Local)" },
{ "Comment", "/** This enables DLSS in play in editor viewports. Saved to local user config only. */" },
{ "DisplayName", "Enable DLSS in Play In Editor viewports" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables DLSS in play in editor viewports. Saved to local user config only." },
};
#endif
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride = { "EnableDLSSInPlayInEditorViewportsOverride", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSOverrideSettings, EnableDLSSInPlayInEditorViewportsOverride), Z_Construct_UEnum_DLSS_EDLSSSettingOverride, METADATA_PARAMS(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_MetaData[] = {
{ "Category", "Editor (Local)" },
{ "Comment", "/** This enables warnings about plugins & tools that are incompatible with DLSS in the editor. Saved to local user config only. */" },
{ "DisplayName", "Warn about incompatible plugins and tools" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables warnings about plugins & tools that are incompatible with DLSS in the editor. Saved to local user config only." },
};
#endif
void Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_SetBit(void* Obj)
{
((UDLSSOverrideSettings*)Obj)->bShowDLSSIncompatiblePluginsToolsWarnings = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings = { "bShowDLSSIncompatiblePluginsToolsWarnings", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSOverrideSettings), &Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings_MetaData)) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages_MetaData[] = {
{ "Category", "Editor (Local)" },
{ "Comment", "/** This enables on screen warnings and errors about DLSS */" },
{ "DisplayName", "Show various DLSS on screen debug messages" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables on screen warnings and errors about DLSS" },
};
#endif
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages = { "ShowDLSSSDebugOnScreenMessages", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSOverrideSettings, ShowDLSSSDebugOnScreenMessages), Z_Construct_UEnum_DLSS_EDLSSSettingOverride, METADATA_PARAMS(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UDLSSOverrideSettings_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInEditorViewportsOverride,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableScreenpercentageManipulationInDLSSEditorViewportsOverride,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_EnableDLSSInPlayInEditorViewportsOverride,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_bShowDLSSIncompatiblePluginsToolsWarnings,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSOverrideSettings_Statics::NewProp_ShowDLSSSDebugOnScreenMessages,
};
const FCppClassTypeInfoStatic Z_Construct_UClass_UDLSSOverrideSettings_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<UDLSSOverrideSettings>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UDLSSOverrideSettings_Statics::ClassParams = {
&UDLSSOverrideSettings::StaticClass,
"Engine",
&StaticCppClassTypeInfo,
DependentSingletons,
nullptr,
Z_Construct_UClass_UDLSSOverrideSettings_Statics::PropPointers,
nullptr,
UE_ARRAY_COUNT(DependentSingletons),
0,
UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::PropPointers),
0,
0x001000E4u,
METADATA_PARAMS(Z_Construct_UClass_UDLSSOverrideSettings_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSOverrideSettings_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_UDLSSOverrideSettings()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UDLSSOverrideSettings_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(UDLSSOverrideSettings, 2893090765);
template<> DLSS_API UClass* StaticClass<UDLSSOverrideSettings>()
{
return UDLSSOverrideSettings::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_UDLSSOverrideSettings(Z_Construct_UClass_UDLSSOverrideSettings, &UDLSSOverrideSettings::StaticClass, TEXT("/Script/DLSS"), TEXT("UDLSSOverrideSettings"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(UDLSSOverrideSettings);
void UDLSSSettings::StaticRegisterNativesUDLSSSettings()
{
}
UClass* Z_Construct_UClass_UDLSSSettings_NoRegister()
{
return UDLSSSettings::StaticClass();
}
struct Z_Construct_UClass_UDLSSSettings_Statics
{
static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bEnableDLSSD3D12_MetaData[];
#endif
static void NewProp_bEnableDLSSD3D12_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnableDLSSD3D12;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bEnableDLSSD3D11_MetaData[];
#endif
static void NewProp_bEnableDLSSD3D11_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnableDLSSD3D11;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bEnableDLSSVulkan_MetaData[];
#endif
static void NewProp_bEnableDLSSVulkan_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnableDLSSVulkan;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bEnableDLSSInEditorViewports_MetaData[];
#endif
static void NewProp_bEnableDLSSInEditorViewports_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnableDLSSInEditorViewports;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_MetaData[];
#endif
static void NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bEnableDLSSInPlayInEditorViewports_MetaData[];
#endif
static void NewProp_bEnableDLSSInPlayInEditorViewports_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEnableDLSSInPlayInEditorViewports;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bShowDLSSSDebugOnScreenMessages_MetaData[];
#endif
static void NewProp_bShowDLSSSDebugOnScreenMessages_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bShowDLSSSDebugOnScreenMessages;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GenericDLSSBinaryPath_MetaData[];
#endif
static const UE4CodeGen_Private::FStrPropertyParams NewProp_GenericDLSSBinaryPath;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bGenericDLSSBinaryExists_MetaData[];
#endif
static void NewProp_bGenericDLSSBinaryExists_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bGenericDLSSBinaryExists;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_NVIDIANGXApplicationId_MetaData[];
#endif
static const UE4CodeGen_Private::FUInt32PropertyParams NewProp_NVIDIANGXApplicationId;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CustomDLSSBinaryPath_MetaData[];
#endif
static const UE4CodeGen_Private::FStrPropertyParams NewProp_CustomDLSSBinaryPath;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bCustomDLSSBinaryExists_MetaData[];
#endif
static void NewProp_bCustomDLSSBinaryExists_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bCustomDLSSBinaryExists;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UDLSSSettings_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_UObject,
(UObject* (*)())Z_Construct_UPackage__Script_DLSS,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::Class_MetaDataParams[] = {
{ "DisplayName", "NVIDIA DLSS" },
{ "IncludePath", "DLSSSettings.h" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
};
#endif
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12_MetaData[] = {
{ "Category", "Platforms" },
{ "Comment", "/** Enable DLSS for D3D12, if the driver supports it at runtime */" },
{ "DisplayName", "Enable DLSS for the D3D12RHI" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "Enable DLSS for D3D12, if the driver supports it at runtime" },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bEnableDLSSD3D12 = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12 = { "bEnableDLSSD3D12", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11_MetaData[] = {
{ "Category", "Platforms" },
{ "Comment", "/** Enable DLSS for D3D11, if the driver supports it at runtime */" },
{ "DisplayName", "Enable DLSS for the D3D11RHI" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "Enable DLSS for D3D11, if the driver supports it at runtime" },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bEnableDLSSD3D11 = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11 = { "bEnableDLSSD3D11", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan_MetaData[] = {
{ "Category", "Platforms" },
{ "Comment", "/** Enable DLSS for Vulkan, if the driver supports it at runtime */" },
{ "DisplayName", "Enable DLSS for the VulkanRHI" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "Enable DLSS for Vulkan, if the driver supports it at runtime" },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bEnableDLSSVulkan = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan = { "bEnableDLSSVulkan", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports_MetaData[] = {
{ "Category", "Level Editor - Viewport" },
{ "Comment", "/** This enables DLSS in editor viewports. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings.*/" },
{ "DisplayName", "Enable DLSS to be turned on in Editor viewports" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables DLSS in editor viewports. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings." },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bEnableDLSSInEditorViewports = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports = { "bEnableDLSSInEditorViewports", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_MetaData[] = {
{ "Category", "Level Editor - Viewport" },
{ "Comment", "/** This setting enables adjusting the screenpercentage directly in the editor, outside of the optimized DLSS quality modes. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings.*/" },
{ "DisplayName", "Enable Screenpercentage Manipulation in DLSS Editor Viewports" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This setting enables adjusting the screenpercentage directly in the editor, outside of the optimized DLSS quality modes. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings." },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bEnableScreenpercentageManipulationInDLSSEditorViewports = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports = { "bEnableScreenpercentageManipulationInDLSSEditorViewports", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports_MetaData[] = {
{ "Category", "Level Editor - Viewport" },
{ "Comment", "/** This enables DLSS in play in editor viewports. This project wide setting can be locally overridden in in the NVIDIA DLSS (Local) settings.*/" },
{ "DisplayName", "Enable DLSS in Play In Editor viewports" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables DLSS in play in editor viewports. This project wide setting can be locally overridden in in the NVIDIA DLSS (Local) settings." },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bEnableDLSSInPlayInEditorViewports = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports = { "bEnableDLSSInPlayInEditorViewports", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages_MetaData[] = {
{ "Category", "Level Editor - Viewport" },
{ "Comment", "/** This enables on screen warnings and errors about DLSS. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings. */" },
{ "DisplayName", "Show various DLSS on screen debug messages" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This enables on screen warnings and errors about DLSS. This project wide setting can be locally overridden in the NVIDIA DLSS (Local) settings." },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bShowDLSSSDebugOnScreenMessages = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages = { "bShowDLSSSDebugOnScreenMessages", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_GenericDLSSBinaryPath_MetaData[] = {
{ "Category", "General Settings" },
{ "Comment", "/** This is part of the DLSS plugin and used by most projects*/" },
{ "DisplayName", "Generic DLSS Binary Path" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "This is part of the DLSS plugin and used by most projects" },
};
#endif
const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_GenericDLSSBinaryPath = { "GenericDLSSBinaryPath", nullptr, (EPropertyFlags)0x0010000000024001, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSSettings, GenericDLSSBinaryPath), METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_GenericDLSSBinaryPath_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_GenericDLSSBinaryPath_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists_MetaData[] = {
{ "Category", "General Settings" },
{ "DisplayName", "Exists" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bGenericDLSSBinaryExists = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists = { "bGenericDLSSBinaryExists", nullptr, (EPropertyFlags)0x0010000000024001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_NVIDIANGXApplicationId_MetaData[] = {
{ "Category", "General Settings" },
{ "Comment", "/** By default the DLSS plugin uses the UE Project ID to initalize DLSS. In some cases NVIDIA might provide a separate NVIDIA Application ID, which should be put here. Please refer to https://developer.nvidia.com/dlss for details*/" },
{ "DisplayName", "NVIDIA NGX Application ID" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "By default the DLSS plugin uses the UE Project ID to initalize DLSS. In some cases NVIDIA might provide a separate NVIDIA Application ID, which should be put here. Please refer to https://developer.nvidia.com/dlss for details" },
};
#endif
const UE4CodeGen_Private::FUInt32PropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_NVIDIANGXApplicationId = { "NVIDIANGXApplicationId", nullptr, (EPropertyFlags)0x0010040000004001, UE4CodeGen_Private::EPropertyGenFlags::UInt32, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSSettings, NVIDIANGXApplicationId), METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_NVIDIANGXApplicationId_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_NVIDIANGXApplicationId_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_CustomDLSSBinaryPath_MetaData[] = {
{ "Category", "General Settings" },
{ "Comment", "/** In some cases NVIDIA might provide a project specific DLSS binary for your project. Please refer to https://developer.nvidia.com/dlss for details*/" },
{ "DisplayName", "Custom DLSS Binary Path" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
{ "ToolTip", "In some cases NVIDIA might provide a project specific DLSS binary for your project. Please refer to https://developer.nvidia.com/dlss for details" },
};
#endif
const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_CustomDLSSBinaryPath = { "CustomDLSSBinaryPath", nullptr, (EPropertyFlags)0x0010040000024001, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UDLSSSettings, CustomDLSSBinaryPath), METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_CustomDLSSBinaryPath_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_CustomDLSSBinaryPath_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists_MetaData[] = {
{ "Category", "General Settings" },
{ "DisplayName", "Exists" },
{ "ModuleRelativePath", "Public/DLSSSettings.h" },
};
#endif
void Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists_SetBit(void* Obj)
{
((UDLSSSettings*)Obj)->bCustomDLSSBinaryExists = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists = { "bCustomDLSSBinaryExists", nullptr, (EPropertyFlags)0x0010040000024001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UDLSSSettings), &Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists_SetBit, METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UDLSSSettings_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D12,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSD3D11,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSVulkan,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInEditorViewports,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableScreenpercentageManipulationInDLSSEditorViewports,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bEnableDLSSInPlayInEditorViewports,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bShowDLSSSDebugOnScreenMessages,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_GenericDLSSBinaryPath,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bGenericDLSSBinaryExists,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_NVIDIANGXApplicationId,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_CustomDLSSBinaryPath,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UDLSSSettings_Statics::NewProp_bCustomDLSSBinaryExists,
};
const FCppClassTypeInfoStatic Z_Construct_UClass_UDLSSSettings_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<UDLSSSettings>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UDLSSSettings_Statics::ClassParams = {
&UDLSSSettings::StaticClass,
"Engine",
&StaticCppClassTypeInfo,
DependentSingletons,
nullptr,
Z_Construct_UClass_UDLSSSettings_Statics::PropPointers,
nullptr,
UE_ARRAY_COUNT(DependentSingletons),
0,
UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::PropPointers),
0,
0x001000A6u,
METADATA_PARAMS(Z_Construct_UClass_UDLSSSettings_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UDLSSSettings_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_UDLSSSettings()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UDLSSSettings_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(UDLSSSettings, 804658016);
template<> DLSS_API UClass* StaticClass<UDLSSSettings>()
{
return UDLSSSettings::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_UDLSSSettings(Z_Construct_UClass_UDLSSSettings, &UDLSSSettings::StaticClass, TEXT("/Script/DLSS"), TEXT("UDLSSSettings"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(UDLSSSettings);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif

186
Plugins/DLSS/Intermediate/Build/Win64/UE4Editor/Inc/DLSS/DLSSSettings.generated.h Normal file
View File

@@ -0,0 +1,186 @@
// 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
#ifdef DLSS_DLSSSettings_generated_h
#error "DLSSSettings.generated.h already included, missing '#pragma once' in DLSSSettings.h"
#endif
#define DLSS_DLSSSettings_generated_h
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_SPARSE_DATA
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_RPC_WRAPPERS
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_RPC_WRAPPERS_NO_PURE_DECLS
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_INCLASS_NO_PURE_DECLS \
private: \
static void StaticRegisterNativesUDLSSOverrideSettings(); \
friend struct Z_Construct_UClass_UDLSSOverrideSettings_Statics; \
public: \
DECLARE_CLASS(UDLSSOverrideSettings, UObject, COMPILED_IN_FLAGS(0 | CLASS_ProjectUserConfig | CLASS_Config), CASTCLASS_None, TEXT("/Script/DLSS"), NO_API) \
DECLARE_SERIALIZER(UDLSSOverrideSettings) \
static const TCHAR* StaticConfigName() {return TEXT("Engine");} \
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_INCLASS \
private: \
static void StaticRegisterNativesUDLSSOverrideSettings(); \
friend struct Z_Construct_UClass_UDLSSOverrideSettings_Statics; \
public: \
DECLARE_CLASS(UDLSSOverrideSettings, UObject, COMPILED_IN_FLAGS(0 | CLASS_ProjectUserConfig | CLASS_Config), CASTCLASS_None, TEXT("/Script/DLSS"), NO_API) \
DECLARE_SERIALIZER(UDLSSOverrideSettings) \
static const TCHAR* StaticConfigName() {return TEXT("Engine");} \
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_STANDARD_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
NO_API UDLSSOverrideSettings(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(UDLSSOverrideSettings) \
DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, UDLSSOverrideSettings); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(UDLSSOverrideSettings); \
private: \
/** Private move- and copy-constructors, should never be used */ \
NO_API UDLSSOverrideSettings(UDLSSOverrideSettings&&); \
NO_API UDLSSOverrideSettings(const UDLSSOverrideSettings&); \
public:
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_ENHANCED_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
NO_API UDLSSOverrideSettings(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \
private: \
/** Private move- and copy-constructors, should never be used */ \
NO_API UDLSSOverrideSettings(UDLSSOverrideSettings&&); \
NO_API UDLSSOverrideSettings(const UDLSSOverrideSettings&); \
public: \
DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, UDLSSOverrideSettings); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(UDLSSOverrideSettings); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(UDLSSOverrideSettings)
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_PRIVATE_PROPERTY_OFFSET
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_29_PROLOG
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_GENERATED_BODY_LEGACY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_PRIVATE_PROPERTY_OFFSET \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_SPARSE_DATA \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_RPC_WRAPPERS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_INCLASS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_STANDARD_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_PRIVATE_PROPERTY_OFFSET \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_SPARSE_DATA \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_RPC_WRAPPERS_NO_PURE_DECLS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_INCLASS_NO_PURE_DECLS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_34_ENHANCED_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
template<> DLSS_API UClass* StaticClass<class UDLSSOverrideSettings>();
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_SPARSE_DATA
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_RPC_WRAPPERS
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_RPC_WRAPPERS_NO_PURE_DECLS
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_INCLASS_NO_PURE_DECLS \
private: \
static void StaticRegisterNativesUDLSSSettings(); \
friend struct Z_Construct_UClass_UDLSSSettings_Statics; \
public: \
DECLARE_CLASS(UDLSSSettings, UObject, COMPILED_IN_FLAGS(0 | CLASS_DefaultConfig | CLASS_Config), CASTCLASS_None, TEXT("/Script/DLSS"), NO_API) \
DECLARE_SERIALIZER(UDLSSSettings) \
static const TCHAR* StaticConfigName() {return TEXT("Engine");} \
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_INCLASS \
private: \
static void StaticRegisterNativesUDLSSSettings(); \
friend struct Z_Construct_UClass_UDLSSSettings_Statics; \
public: \
DECLARE_CLASS(UDLSSSettings, UObject, COMPILED_IN_FLAGS(0 | CLASS_DefaultConfig | CLASS_Config), CASTCLASS_None, TEXT("/Script/DLSS"), NO_API) \
DECLARE_SERIALIZER(UDLSSSettings) \
static const TCHAR* StaticConfigName() {return TEXT("Engine");} \
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_STANDARD_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
NO_API UDLSSSettings(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(UDLSSSettings) \
DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, UDLSSSettings); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(UDLSSSettings); \
private: \
/** Private move- and copy-constructors, should never be used */ \
NO_API UDLSSSettings(UDLSSSettings&&); \
NO_API UDLSSSettings(const UDLSSSettings&); \
public:
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_ENHANCED_CONSTRUCTORS \
/** Standard constructor, called after all reflected properties have been initialized */ \
NO_API UDLSSSettings(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \
private: \
/** Private move- and copy-constructors, should never be used */ \
NO_API UDLSSSettings(UDLSSSettings&&); \
NO_API UDLSSSettings(const UDLSSSettings&); \
public: \
DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, UDLSSSettings); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(UDLSSSettings); \
DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(UDLSSSettings)
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_PRIVATE_PROPERTY_OFFSET
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_58_PROLOG
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_GENERATED_BODY_LEGACY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_PRIVATE_PROPERTY_OFFSET \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_SPARSE_DATA \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_RPC_WRAPPERS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_INCLASS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_STANDARD_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#define f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_PRIVATE_PROPERTY_OFFSET \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_SPARSE_DATA \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_RPC_WRAPPERS_NO_PURE_DECLS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_INCLASS_NO_PURE_DECLS \
f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h_61_ENHANCED_CONSTRUCTORS \
private: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS
template<> DLSS_API UClass* StaticClass<class UDLSSSettings>();
#undef CURRENT_FILE_ID
#define CURRENT_FILE_ID f0re5t_main_Plugins_DLSS_Source_DLSS_Public_DLSSSettings_h
#define FOREACH_ENUM_EDLSSSETTINGOVERRIDE(op) \
op(EDLSSSettingOverride::Enabled) \
op(EDLSSSettingOverride::Disabled) \
op(EDLSSSettingOverride::UseProjectSettings)
enum class EDLSSSettingOverride : uint8;
template<> DLSS_API UEnum* StaticEnum<EDLSSSettingOverride>();
PRAGMA_ENABLE_DEPRECATION_WARNINGS

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

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

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