diff --git a/OptiScaler.ini b/OptiScaler.ini index f29965cf..6860332c 100644 --- a/OptiScaler.ini +++ b/OptiScaler.ini @@ -319,7 +319,7 @@ RenderPresetUltraPerformance=auto ; ------------------------------------------------------- -[DLSSG] +[Nukems] ; ------------------------------------------------------- ; Fix broken visuals in some games (mostly non-UE) on AMD GPUs under Windows ; Can cause stutters so best to use only when necessary diff --git a/OptiScaler/Config.cpp b/OptiScaler/Config.cpp index 51d7c5c8..aadff569 100644 --- a/OptiScaler/Config.cpp +++ b/OptiScaler/Config.cpp @@ -135,25 +135,27 @@ bool Config::Reload(std::filesystem::path iniPath) RenderPresetOverride.set_from_config(readBool("DLSS", "RenderPresetOverride")); - if (auto setting = readInt("DLSS", "RenderPresetForAll"); setting.has_value() && setting >= 0 && setting <= 15) + constexpr size_t presetCount = 17; + + if (auto setting = readInt("DLSS", "RenderPresetForAll"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetForAll.set_from_config(setting); - if (auto setting = readInt("DLSS", "RenderPresetDLAA"); setting.has_value() && setting >= 0 && setting <= 15) + if (auto setting = readInt("DLSS", "RenderPresetDLAA"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetDLAA.set_from_config(setting); - if (auto setting = readInt("DLSS", "RenderPresetUltraQuality"); setting.has_value() && setting >= 0 && setting <= 15) + if (auto setting = readInt("DLSS", "RenderPresetUltraQuality"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetUltraQuality.set_from_config(setting); - if (auto setting = readInt("DLSS", "RenderPresetQuality"); setting.has_value() && setting >= 0 && setting <= 15) + if (auto setting = readInt("DLSS", "RenderPresetQuality"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetQuality.set_from_config(setting); - if (auto setting = readInt("DLSS", "RenderPresetBalanced"); setting.has_value() && setting >= 0 && setting <= 15) + if (auto setting = readInt("DLSS", "RenderPresetBalanced"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetBalanced.set_from_config(setting); - if (auto setting = readInt("DLSS", "RenderPresetPerformance"); setting.has_value() && setting >= 0 && setting <= 15) + if (auto setting = readInt("DLSS", "RenderPresetPerformance"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetPerformance.set_from_config(setting); - if (auto setting = readInt("DLSS", "RenderPresetUltraPerformance"); setting.has_value() && setting >= 0 && setting <= 15) + if (auto setting = readInt("DLSS", "RenderPresetUltraPerformance"); setting.has_value() && setting >= 0 && (setting < presetCount || setting == 0x00FFFFFF)) RenderPresetUltraPerformance.set_from_config(setting); } @@ -613,13 +615,13 @@ bool Config::SaveIni() ini.SetValue("DLSS", "LibraryPath", wstring_to_string(Instance()->NvngxPath.value_for_config_or(L"auto")).c_str()); ini.SetValue("DLSS", "NVNGX_DLSS_Library", wstring_to_string(Instance()->NVNGX_DLSS_Library.value_for_config_or(L"auto")).c_str()); ini.SetValue("DLSS", "RenderPresetOverride", GetBoolValue(Instance()->RenderPresetOverride.value_for_config()).c_str()); - ini.SetValue("DLSS", "RenderPresetForAll", GetIntValue(Instance()->RenderPresetForAll).c_str()); - ini.SetValue("DLSS", "RenderPresetDLAA", GetIntValue(Instance()->RenderPresetDLAA).c_str()); - ini.SetValue("DLSS", "RenderPresetUltraQuality", GetIntValue(Instance()->RenderPresetUltraQuality).c_str()); - ini.SetValue("DLSS", "RenderPresetQuality", GetIntValue(Instance()->RenderPresetQuality).c_str()); - ini.SetValue("DLSS", "RenderPresetBalanced", GetIntValue(Instance()->RenderPresetBalanced).c_str()); - ini.SetValue("DLSS", "RenderPresetPerformance", GetIntValue(Instance()->RenderPresetPerformance).c_str()); - ini.SetValue("DLSS", "RenderPresetUltraPerformance", GetIntValue(Instance()->RenderPresetUltraPerformance).c_str()); + ini.SetValue("DLSS", "RenderPresetForAll", GetIntValue(Instance()->RenderPresetForAll.value_for_config()).c_str()); + ini.SetValue("DLSS", "RenderPresetDLAA", GetIntValue(Instance()->RenderPresetDLAA.value_for_config()).c_str()); + ini.SetValue("DLSS", "RenderPresetUltraQuality", GetIntValue(Instance()->RenderPresetUltraQuality.value_for_config()).c_str()); + ini.SetValue("DLSS", "RenderPresetQuality", GetIntValue(Instance()->RenderPresetQuality.value_for_config()).c_str()); + ini.SetValue("DLSS", "RenderPresetBalanced", GetIntValue(Instance()->RenderPresetBalanced.value_for_config()).c_str()); + ini.SetValue("DLSS", "RenderPresetPerformance", GetIntValue(Instance()->RenderPresetPerformance.value_for_config()).c_str()); + ini.SetValue("DLSS", "RenderPresetUltraPerformance", GetIntValue(Instance()->RenderPresetUltraPerformance.value_for_config()).c_str()); } // Nukems diff --git a/OptiScaler/OptiScaler.vcxproj b/OptiScaler/OptiScaler.vcxproj index 14e01a88..7ea3ddf5 100644 --- a/OptiScaler/OptiScaler.vcxproj +++ b/OptiScaler/OptiScaler.vcxproj @@ -415,6 +415,10 @@ copy NUL "$(SolutionDir)x64\Release\a\!! EXTRACT ALL FILES TO GAME FOLDER !!" /Y + + + + diff --git a/OptiScaler/OptiScaler.vcxproj.filters b/OptiScaler/OptiScaler.vcxproj.filters index 4281fd29..fae65156 100644 --- a/OptiScaler/OptiScaler.vcxproj.filters +++ b/OptiScaler/OptiScaler.vcxproj.filters @@ -608,6 +608,18 @@ Source Files + + Source Files + + + Source Files + + + Source Files + + + Source Files + diff --git a/OptiScaler/State.h b/OptiScaler/State.h index f5ea5f95..9d5c0ea4 100644 --- a/OptiScaler/State.h +++ b/OptiScaler/State.h @@ -93,8 +93,10 @@ public: float lastMipBias = 100.0f; float lastMipBiasMax = -100.0f; - // DLSS Hook + // DLSS bool upscalerDisableHook = false; + bool dlssPresetsOverriddenExternally = false; + bool dlssdPresetsOverriddenExternally = false; // Spoofing bool skipSpoofing = false; diff --git a/OptiScaler/hooks/HooksDx.cpp b/OptiScaler/hooks/HooksDx.cpp index 1d911b46..934780e8 100644 --- a/OptiScaler/hooks/HooksDx.cpp +++ b/OptiScaler/hooks/HooksDx.cpp @@ -2,11 +2,12 @@ #include "wrapped_swapchain.h" #include -#include #include #include #include +#include +#include #include @@ -16,6 +17,8 @@ #include #include +#include "nvapi/ReflexHooks.h" + // Clear heap info when ResourceDiscard is called //#define USE_RESOURCE_DISCARD diff --git a/OptiScaler/hooks/HooksDx.h b/OptiScaler/hooks/HooksDx.h index 38bb82e0..0e0088b7 100644 --- a/OptiScaler/hooks/HooksDx.h +++ b/OptiScaler/hooks/HooksDx.h @@ -29,9 +29,6 @@ #include #include -#include -#include -#include namespace HooksDx { diff --git a/OptiScaler/menu/menu_common.cpp b/OptiScaler/menu/menu_common.cpp index d50a03ef..a2468061 100644 --- a/OptiScaler/menu/menu_common.cpp +++ b/OptiScaler/menu/menu_common.cpp @@ -695,7 +695,8 @@ template void MenuCommon::AddRenderPreset(std::string name, CustomOptional* value) { const char* presets[] = { "DEFAULT", "PRESET A", "PRESET B", "PRESET C", "PRESET D", "PRESET E", "PRESET F", "PRESET G", - "PRESET H", "PRESET I", "PRESET J", "PRESET K", "PRESET L", "PRESET M", "PRESET N", "PRESET O" }; + "PRESET H", "PRESET I", "PRESET J", "PRESET K", "PRESET L", "PRESET M", "PRESET N", "PRESET O", + "Latest"}; const std::string presetsDesc[] = { "Whatever the game uses", "Intended for Performance/Balanced/Quality modes.\nAn older variant best suited to combat ghosting for elements with missing inputs, such as motion vectors.", "Intended for Ultra Performance mode.\nSimilar to Preset A but for Ultra Performance mode.", @@ -712,10 +713,19 @@ void MenuCommon::AddRenderPreset(std::string name, CustomOptional* "Unused", "Unused", "Unused", - "Unused" + "Unused", + + "Latest supported by the dll" }; - PopulateCombo(name, value, presets, presetsDesc, 16); + if (value->value_or_default() == 0x00FFFFFF) + *value = 16; + + PopulateCombo(name, value, presets, presetsDesc, std::size(presets)); + + // Value for latest preset + if (value->value_or_default() == 16) + *value = 0x00FFFFFF; } template @@ -1939,12 +1949,24 @@ bool MenuCommon::RenderMenu() { ImGui::SeparatorText("DLSS Settings"); + auto overridden = (State::Instance().dlssPresetsOverriddenExternally && currentBackend == "dlss") || (State::Instance().dlssdPresetsOverriddenExternally && State::Instance().currentFeature->Name() == "DLSSD"); + + if (overridden) { + ImGui::TextColored(ImVec4(1.f, 0.f, 0.f, 1.f), "Presets are overridden externally"); + ShowHelpMarker("This usually happens due to using tools\n" + "such as Nvidia App or Nvidia Inspector"); + ImGui::Text("Selecting setting below will disable that external override\n" + "but you need to Save INI and restart the game"); + + ImGui::Spacing(); + } + if (bool pOverride = Config::Instance()->RenderPresetOverride.value_or_default(); ImGui::Checkbox("Render Presets Override", &pOverride)) Config::Instance()->RenderPresetOverride = pOverride; ShowHelpMarker("Each render preset has it strengths and weaknesses\n" "Override to potentially improve image quality"); - + ImGui::BeginDisabled(!Config::Instance()->RenderPresetOverride.value_or_default() || overridden); ImGui::PushItemWidth(135.0 * Config::Instance()->MenuScale.value_or_default()); AddRenderPreset("Override Preset", &Config::Instance()->RenderPresetForAll); @@ -1962,6 +1984,8 @@ bool MenuCommon::RenderMenu() State::Instance().changeBackend = true; } + ImGui::EndDisabled(); + ImGui::Spacing(); if (ImGui::CollapsingHeader("Advanced DLSS Settings")) @@ -1975,6 +1999,7 @@ bool MenuCommon::RenderMenu() "Fixes OptiScaler preset override not working with certain games\n" "Requires a game restart."); + ImGui::BeginDisabled(!Config::Instance()->RenderPresetOverride.value_or_default() || overridden); ImGui::Spacing(); ImGui::PushItemWidth(135.0 * Config::Instance()->MenuScale.value_or_default()); AddRenderPreset("DLAA Preset", &Config::Instance()->RenderPresetDLAA); @@ -1984,6 +2009,7 @@ bool MenuCommon::RenderMenu() AddRenderPreset("Perf Preset", &Config::Instance()->RenderPresetPerformance); AddRenderPreset("UltraP Preset", &Config::Instance()->RenderPresetUltraPerformance); ImGui::PopItemWidth(); + ImGui::EndDisabled(); } ImGui::Spacing(); @@ -2167,8 +2193,12 @@ bool MenuCommon::RenderMenu() ImGui::Text(std::format("Current method: {}", State::Instance().reflexLimitsFps ? "Reflex" : "Fallback").c_str()); if (State::Instance().reflexShowWarning) + { ImGui::TextColored(ImVec4(1.f, 0.f, 0.f, 1.f), "Using Reflex's limit with OptiFG has performance overhead"); + ImGui::Spacing(); + } + // set initial value if (_limitFps == INFINITY) _limitFps = Config::Instance()->FramerateLimit.value_or_default(); @@ -2696,7 +2726,7 @@ bool MenuCommon::RenderMenu() Config::Instance()->Fsr3Inputs = fsr3Inputs; if (ImGui::Checkbox("Use Fsr3 Pattern Matching", &fsr3Pattern)) - Config::Instance()->Fsr3Pattern = fsr2Pattern; + Config::Instance()->Fsr3Pattern = fsr3Pattern; ShowTooltip("This setting will become active on next boot!"); if (ImGui::Checkbox("Use Ffx Inputs", &ffxInputs)) diff --git a/OptiScaler/nvapi/NvApiHooks.cpp b/OptiScaler/nvapi/NvApiHooks.cpp new file mode 100644 index 00000000..748ac871 --- /dev/null +++ b/OptiScaler/nvapi/NvApiHooks.cpp @@ -0,0 +1,142 @@ +#include "NvApiHooks.h" +#include +#include "State.h" +#include +#include + +NvAPI_Status __stdcall NvApiHooks::hkNvAPI_GPU_GetArchInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_ARCH_INFO* pGpuArchInfo) +{ + if (!o_NvAPI_GPU_GetArchInfo) + { + LOG_DEBUG("nullptr"); + return NVAPI_ERROR; + } + + const auto status = o_NvAPI_GPU_GetArchInfo(hPhysicalGpu, pGpuArchInfo); + + if (status == NVAPI_OK && pGpuArchInfo) + { + LOG_DEBUG("Original arch: {0:X} impl: {1:X} rev: {2:X}!", pGpuArchInfo->architecture, pGpuArchInfo->implementation, pGpuArchInfo->revision); + + // for DLSS on 16xx cards + // Can't spoof ada for DLSSG here as that breaks DLSS/DLSSD + if (pGpuArchInfo->architecture == NV_GPU_ARCHITECTURE_TU100 && pGpuArchInfo->implementation > NV_GPU_ARCH_IMPLEMENTATION_TU106) + { + pGpuArchInfo->implementation = NV_GPU_ARCH_IMPLEMENTATION_TU106; + LOG_INFO("Spoofed arch: {0:X} impl: {1:X} rev: {2:X}!", pGpuArchInfo->architecture, pGpuArchInfo->implementation, pGpuArchInfo->revision); + } + } + + return status; +} + +NvAPI_Status __stdcall NvApiHooks::hkNvAPI_DRS_GetSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId, NVDRS_SETTING* pSetting) +{ + if (!o_NvAPI_DRS_GetSetting) + return NVAPI_ERROR; + + auto result = o_NvAPI_DRS_GetSetting(hSession, hProfile, settingId, pSetting); + if (pSetting && result == NVAPI_OK) + { + if (settingId == NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_ID) + { + if (Config::Instance()->RenderPresetOverride.value_or_default()) + pSetting->u32CurrentValue = NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF; + else + State::Instance().dlssPresetsOverriddenExternally = pSetting->u32CurrentValue != NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF; + } + + if (settingId == NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_ID) + { + if (Config::Instance()->RenderPresetOverride.value_or_default()) + pSetting->u32CurrentValue = NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF; + else + State::Instance().dlssdPresetsOverriddenExternally = pSetting->u32CurrentValue != NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF; + } + } + + return result; +} + +void* __stdcall NvApiHooks::hkNvAPI_QueryInterface(unsigned int InterfaceId) +{ + if (!o_NvAPI_QueryInterface) + return nullptr; + + //LOG_DEBUG("counter: {} InterfaceId: {:X}", ++qiCounter, (uint32_t)InterfaceId); + + if (InterfaceId == GET_ID(NvAPI_D3D_SetSleepMode) || + InterfaceId == GET_ID(NvAPI_D3D_Sleep) || + InterfaceId == GET_ID(NvAPI_D3D_GetLatency) || + InterfaceId == GET_ID(NvAPI_D3D_SetLatencyMarker) || + InterfaceId == GET_ID(NvAPI_D3D12_SetAsyncFrameMarker)) + { + //LOG_DEBUG("counter: {}, hookReflex()", qiCounter); + ReflexHooks::hookReflex(o_NvAPI_QueryInterface); + return ReflexHooks::getHookedReflex(InterfaceId); + } + + ReflexHooks::hookReflex(o_NvAPI_QueryInterface); + + const auto functionPointer = o_NvAPI_QueryInterface(InterfaceId); + + if (functionPointer) + { + if (InterfaceId == GET_ID(NvAPI_GPU_GetArchInfo) && !State::Instance().enablerAvailable) + { + o_NvAPI_GPU_GetArchInfo = static_cast(functionPointer); + return &hkNvAPI_GPU_GetArchInfo; + } + if (InterfaceId == GET_ID(NvAPI_DRS_GetSetting)) + { + o_NvAPI_DRS_GetSetting = static_cast(functionPointer); + return &hkNvAPI_DRS_GetSetting; + } + } + + //LOG_DEBUG("counter: {} functionPointer: {:X}", qiCounter, (size_t)functionPointer); + + return functionPointer; +} + +// Requires HMODULE to make sure nvapi is loaded before calling this function +void NvApiHooks::Hook(HMODULE nvapiModule) +{ + if (o_NvAPI_QueryInterface != nullptr) + return; + + if (nvapiModule == nullptr) { + LOG_ERROR("Hook called with a nullptr nvapi module"); + return; + } + + LOG_DEBUG("Trying to hook NvApi"); + + o_NvAPI_QueryInterface = (PFN_NvApi_QueryInterface)GetProcAddress(nvapiModule, "nvapi_QueryInterface"); + + LOG_DEBUG("OriginalNvAPI_QueryInterface = {0:X}", (unsigned long long)o_NvAPI_QueryInterface); + + if (o_NvAPI_QueryInterface != nullptr) + { + LOG_INFO("NvAPI_QueryInterface found, hooking!"); + fakenvapi::Init(o_NvAPI_QueryInterface); + + DetourTransactionBegin(); + DetourUpdateThread(GetCurrentThread()); + DetourAttach(&(PVOID&)o_NvAPI_QueryInterface, hkNvAPI_QueryInterface); + DetourTransactionCommit(); + } +} + +void NvApiHooks::Unhook() { + DetourTransactionBegin(); + DetourUpdateThread(GetCurrentThread()); + + if (o_NvAPI_QueryInterface != nullptr) + { + DetourDetach(&(PVOID&)o_NvAPI_QueryInterface, hkNvAPI_QueryInterface); + o_NvAPI_QueryInterface = nullptr; + } + + DetourTransactionCommit(); +} \ No newline at end of file diff --git a/OptiScaler/nvapi/NvApiHooks.h b/OptiScaler/nvapi/NvApiHooks.h index fe3ac4cb..e0536487 100644 --- a/OptiScaler/nvapi/NvApiHooks.h +++ b/OptiScaler/nvapi/NvApiHooks.h @@ -1,142 +1,19 @@ #pragma once - -#include #include "NvApiTypes.h" #include "ReflexHooks.h" #include "fakenvapi.h" class NvApiHooks { public: - // NvAPI_GPU_GetArchInfo hooking based on Nukem's spoofing code here - // https://github.com/Nukem9/dlssg-to-fsr3/blob/89ddc8c1cce4593fb420e633a06605c3c4b9c3cf/source/wrapper_generic/nvapi.cpp#L50 + inline static PFN_NvApi_QueryInterface o_NvAPI_QueryInterface = nullptr; + inline static decltype(&NvAPI_GPU_GetArchInfo) o_NvAPI_GPU_GetArchInfo = nullptr; + inline static decltype(&NvAPI_DRS_GetSetting) o_NvAPI_DRS_GetSetting = nullptr; - inline static NvApiTypes::PFN_NvApi_QueryInterface OriginalNvAPI_QueryInterface = nullptr; - inline static NvApiTypes::PfnNvAPI_GPU_GetArchInfo OriginalNvAPI_GPU_GetArchInfo = nullptr; + //inline static UINT64 qiCounter = 0; - inline static uint32_t __stdcall HookedNvAPI_GPU_GetArchInfo(void* GPUHandle, NV_GPU_ARCH_INFO* ArchInfo) - { - if (OriginalNvAPI_GPU_GetArchInfo) - { - const auto status = OriginalNvAPI_GPU_GetArchInfo(GPUHandle, ArchInfo); - - if (status == 0 && ArchInfo) - { - LOG_DEBUG("From api arch: {0:X} impl: {1:X} rev: {2:X}!", ArchInfo->architecture, ArchInfo->implementation, ArchInfo->revision); - - // for DLSSG on pre-20xx cards - // Needs more controlled way of spoofing, was breaking DLSS-D - // Leaving DLSS-G spoofing to Nukem's mod for now - //if (Config::Instance()->FGType.value_or_default() == FGType::Nukems && ArchInfo->architecture >= NV_GPU_ARCHITECTURE_GM200 && ArchInfo->architecture < NV_GPU_ARCHITECTURE_AD100) { // only GTX9xx+ supports latest reflex - // if (ArchInfo->architecture == NV_GPU_ARCHITECTURE_TU100 && ArchInfo->implementation > NV_GPU_ARCH_IMPLEMENTATION_TU106) { - // ArchInfo->implementation = NV_GPU_ARCH_IMPLEMENTATION_TU106; // let nukem's mod change the arch for those cards, breaks dlss otherwise for some reason - // } - // else { - // ArchInfo->architecture = NV_GPU_ARCHITECTURE_AD100; - // ArchInfo->implementation = NV_GPU_ARCH_IMPLEMENTATION_AD102; - // } - - // LOG_INFO("Spoofed arch for dlssg: {0:X} impl: {1:X} rev: {2:X}!", ArchInfo->architecture, ArchInfo->implementation, ArchInfo->revision); - //} - - // for DLSS on 16xx cards - if (ArchInfo->architecture == NV_GPU_ARCHITECTURE_TU100 && ArchInfo->implementation > NV_GPU_ARCH_IMPLEMENTATION_TU106) - { - ArchInfo->implementation = NV_GPU_ARCH_IMPLEMENTATION_TU106; - - LOG_INFO("Spoofed arch: {0:X} impl: {1:X} rev: {2:X}!", ArchInfo->architecture, ArchInfo->implementation, ArchInfo->revision); - } - } - - return status; - } - - LOG_DEBUG("return 0xFFFFFFFF"); - return 0xFFFFFFFF; - } - - inline static UINT64 qiCounter = 0; - - inline static void* __stdcall HookedNvAPI_QueryInterface(NvApiTypes::NV_INTERFACE InterfaceId) - { - //LOG_DEBUG("counter: {} InterfaceId: {:X}", ++qiCounter, (uint32_t)InterfaceId); - - switch (InterfaceId) - { - case NvApiTypes::NV_INTERFACE::D3D_SetSleepMode: - case NvApiTypes::NV_INTERFACE::D3D_Sleep: - case NvApiTypes::NV_INTERFACE::D3D_GetLatency: - case NvApiTypes::NV_INTERFACE::D3D_SetLatencyMarker: - case NvApiTypes::NV_INTERFACE::D3D12_SetAsyncFrameMarker: - //LOG_DEBUG("counter: {}, hookReflex()", qiCounter); - ReflexHooks::hookReflex(OriginalNvAPI_QueryInterface); - return ReflexHooks::getHookedReflex(InterfaceId); - - default: - ReflexHooks::hookReflex(OriginalNvAPI_QueryInterface); - } - - const auto functionPointer = OriginalNvAPI_QueryInterface(InterfaceId); - - if (functionPointer) - { - switch (InterfaceId) - { - case NvApiTypes::NV_INTERFACE::GPU_GetArchInfo: - //LOG_DEBUG("GPU_GetArchInfo"); - - if (!State::Instance().enablerAvailable) { - OriginalNvAPI_GPU_GetArchInfo = static_cast(functionPointer); - return &HookedNvAPI_GPU_GetArchInfo; - } - - break; - } - } - - //LOG_DEBUG("counter: {} functionPointer: {:X}", qiCounter, (size_t)functionPointer); - - return functionPointer; - } - - // Requires HMODULE to make sure nvapi is loaded before calling this function - inline static void Hook(HMODULE nvapiModule) - { - if (OriginalNvAPI_QueryInterface != nullptr) - return; - - if (nvapiModule == nullptr) { - LOG_ERROR("Hook called with a nullptr nvapi module"); - return; - } - - LOG_DEBUG("Trying to hook NvApi"); - - OriginalNvAPI_QueryInterface = (NvApiTypes::PFN_NvApi_QueryInterface)GetProcAddress(nvapiModule, "nvapi_QueryInterface"); - - LOG_DEBUG("OriginalNvAPI_QueryInterface = {0:X}", (unsigned long long)OriginalNvAPI_QueryInterface); - - if (OriginalNvAPI_QueryInterface != nullptr) - { - LOG_INFO("NvAPI_QueryInterface found, hooking!"); - fakenvapi::Init((fakenvapi::PFN_Fake_QueryInterface&)OriginalNvAPI_QueryInterface); - - DetourTransactionBegin(); - DetourUpdateThread(GetCurrentThread()); - DetourAttach(&(PVOID&)OriginalNvAPI_QueryInterface, HookedNvAPI_QueryInterface); - DetourTransactionCommit(); - } - } - - inline static void Unhook() { - DetourTransactionBegin(); - DetourUpdateThread(GetCurrentThread()); - - if (OriginalNvAPI_QueryInterface != nullptr) - { - DetourDetach(&(PVOID&)OriginalNvAPI_QueryInterface, HookedNvAPI_QueryInterface); - OriginalNvAPI_QueryInterface = nullptr; - } - - DetourTransactionCommit(); - } + static NvAPI_Status __stdcall hkNvAPI_GPU_GetArchInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_ARCH_INFO* pGpuArchInfo); + static NvAPI_Status __stdcall hkNvAPI_DRS_GetSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId, NVDRS_SETTING* pSetting); + static void* __stdcall hkNvAPI_QueryInterface(unsigned int InterfaceId); + static void Hook(HMODULE nvapiModule); + static void Unhook(); }; \ No newline at end of file diff --git a/OptiScaler/nvapi/NvApiTypes.cpp b/OptiScaler/nvapi/NvApiTypes.cpp new file mode 100644 index 00000000..2c64bfeb --- /dev/null +++ b/OptiScaler/nvapi/NvApiTypes.cpp @@ -0,0 +1,32 @@ +#include "NvApiTypes.h" + +#include + +constexpr NVAPI_INTERFACE_TABLE fakenvapi_extra[] = +{ + {"Fake_InformFGState", 0x21382138 }, + {"Fake_InformPresentFG", 0x21392139 }, + { "Fake_GetAntiLagCtx", 0x21402140 } +}; + +NvApiTypes::NvApiTypes() { + for (const auto& entry : nvapi_interface_table) { + lookupTable[entry.func] = entry.id; + } + for (const auto& entry : fakenvapi_extra) { + lookupTable[entry.func] = entry.id; + } +} +NvApiTypes& NvApiTypes::Instance() { + static NvApiTypes instance; + return instance; +} + +unsigned int NvApiTypes::getId(const std::string& name) const { + auto it = lookupTable.find(name); + if (it != lookupTable.end()) { + return it->second; + } + LOG_TRACE("Not a known nvapi interface"); + return 0; +} diff --git a/OptiScaler/nvapi/NvApiTypes.h b/OptiScaler/nvapi/NvApiTypes.h index 4821d616..73542e2d 100644 --- a/OptiScaler/nvapi/NvApiTypes.h +++ b/OptiScaler/nvapi/NvApiTypes.h @@ -5,21 +5,19 @@ #include #include +#define GET_ID(name) NvApiTypes::Instance().getId(#name) + +typedef void* (__stdcall* PFN_NvApi_QueryInterface)(unsigned int InterfaceId); +typedef NvAPI_Status(__stdcall* PFN_Fake_InformFGState)(bool fg_state); +typedef NvAPI_Status(__stdcall* PFN_Fake_InformPresentFG)(bool frame_interpolated, uint64_t reflex_frame_id); +typedef NvAPI_Status(__stdcall* PFN_Fake_GetAntiLagCtx)(void* al2_context); + // Separate to break up a circular dependency class NvApiTypes { + std::unordered_map lookupTable; + + NvApiTypes(); public: - enum class NV_INTERFACE : uint32_t - { - GPU_GetArchInfo = 0xD8265D24, - D3D12_SetRawScgPriority = 0x5DB3048A, - D3D_SetSleepMode = 0xac1ca9e0, - D3D_Sleep = 0x852cd1d2, - D3D_GetLatency = 0x1a587f9c, - D3D_SetLatencyMarker = 0xd9984c05, - D3D12_SetAsyncFrameMarker = 0x13c98f73, - }; - - typedef void* (__stdcall* PFN_NvApi_QueryInterface)(NV_INTERFACE InterfaceId); - - using PfnNvAPI_GPU_GetArchInfo = uint32_t(__stdcall*)(void* GPUHandle, NV_GPU_ARCH_INFO* ArchInfo); + static NvApiTypes& Instance(); + unsigned int getId(const std::string& name) const; }; diff --git a/OptiScaler/nvapi/ReflexHooks.cpp b/OptiScaler/nvapi/ReflexHooks.cpp new file mode 100644 index 00000000..306d4538 --- /dev/null +++ b/OptiScaler/nvapi/ReflexHooks.cpp @@ -0,0 +1,206 @@ +#include "ReflexHooks.h" +#include + +#include "fakenvapi.h" + +//#define LOG_REFLEX_CALLS + +NvAPI_Status ReflexHooks::hkNvAPI_D3D_SetSleepMode(IUnknown* pDev, NV_SET_SLEEP_MODE_PARAMS* pSetSleepModeParams) { +#ifdef LOG_REFLEX_CALLS + LOG_FUNC(); +#endif + // Store for later so we can adjust the fps whenever we want + memcpy(&_lastSleepParams, pSetSleepModeParams, sizeof(NV_SET_SLEEP_MODE_PARAMS)); + _lastSleepDev = pDev; + + if (_minimumIntervalUs != 0) + pSetSleepModeParams->minimumIntervalUs = _minimumIntervalUs; + + return o_NvAPI_D3D_SetSleepMode(pDev, pSetSleepModeParams); +} + +NvAPI_Status ReflexHooks::hkNvAPI_D3D_Sleep(IUnknown* pDev) { +#ifdef LOG_REFLEX_CALLS + LOG_FUNC(); +#endif + + return o_NvAPI_D3D_Sleep(pDev); +} + +NvAPI_Status ReflexHooks::hkNvAPI_D3D_GetLatency(IUnknown* pDev, NV_LATENCY_RESULT_PARAMS* pGetLatencyParams) { +#ifdef LOG_REFLEX_CALLS + LOG_FUNC(); +#endif + + return o_NvAPI_D3D_GetLatency(pDev, pGetLatencyParams); +} + +NvAPI_Status ReflexHooks::hkNvAPI_D3D_SetLatencyMarker(IUnknown* pDev, NV_LATENCY_MARKER_PARAMS* pSetLatencyMarkerParams) { +#ifdef LOG_REFLEX_CALLS + LOG_FUNC(); +#endif + _updatesWithoutMarker = 0; + + // Some games just stop sending any async markers when DLSSG is disabled, so a reset is needed + if (_lastAsyncMarkerFrameId + 10 < pSetLatencyMarkerParams->frameID) + _dlssgDetected = false; + + return o_NvAPI_D3D_SetLatencyMarker(pDev, pSetLatencyMarkerParams); +} + +NvAPI_Status ReflexHooks::hkNvAPI_D3D12_SetAsyncFrameMarker(ID3D12CommandQueue* pCommandQueue, NV_ASYNC_FRAME_MARKER_PARAMS* pSetAsyncFrameMarkerParams) { +#ifdef LOG_REFLEX_CALLS + LOG_FUNC(); +#endif + + _lastAsyncMarkerFrameId = pSetAsyncFrameMarkerParams->frameID; + + if (pSetAsyncFrameMarkerParams->markerType == OUT_OF_BAND_PRESENT_START) { + constexpr size_t history_size = 12; + static size_t counter = 0; + static NvU64 previous_frame_ids[history_size] = {}; + + previous_frame_ids[counter % history_size] = pSetAsyncFrameMarkerParams->frameID; + counter++; + + size_t repeat_count = 0; + + for (size_t i = 1; i < history_size; i++) { + // won't catch repeat frame ids across array wrap around + if (previous_frame_ids[i] == previous_frame_ids[i - 1]) { + repeat_count++; + } + } + + if (_dlssgDetected && repeat_count == 0) { + _dlssgDetected = false; + LOG_DEBUG("DLSS FG no longer detected"); + } + else if (!_dlssgDetected && repeat_count >= history_size / 2 - 1) { + _dlssgDetected = true; + LOG_DEBUG("DLSS FG detected"); + } + } + + return o_NvAPI_D3D12_SetAsyncFrameMarker(pCommandQueue, pSetAsyncFrameMarkerParams); +} + +void ReflexHooks::hookReflex(PFN_NvApi_QueryInterface& queryInterface) { +#ifdef _DEBUG + LOG_FUNC(); +#endif + + if (!_inited) { + o_NvAPI_D3D_SetSleepMode = static_cast(queryInterface(GET_ID(NvAPI_D3D_SetSleepMode))); + o_NvAPI_D3D_Sleep = static_cast(queryInterface(GET_ID(NvAPI_D3D_Sleep))); + o_NvAPI_D3D_GetLatency = static_cast(queryInterface(GET_ID(NvAPI_D3D_GetLatency))); + o_NvAPI_D3D_SetLatencyMarker = static_cast(queryInterface(GET_ID(NvAPI_D3D_SetLatencyMarker))); + o_NvAPI_D3D12_SetAsyncFrameMarker = static_cast(queryInterface(GET_ID(NvAPI_D3D12_SetAsyncFrameMarker))); + + _inited = o_NvAPI_D3D_SetSleepMode && o_NvAPI_D3D_Sleep && o_NvAPI_D3D_GetLatency && o_NvAPI_D3D_SetLatencyMarker && o_NvAPI_D3D12_SetAsyncFrameMarker; + + if (_inited) + LOG_DEBUG("Inited Reflex hooks"); + } +} + +bool ReflexHooks::isDlssgDetected() +{ + return _dlssgDetected; +} + +bool ReflexHooks::isReflexHooked() +{ + return _inited; +} + +void* ReflexHooks::getHookedReflex(unsigned int InterfaceId) { + if (InterfaceId == GET_ID(NvAPI_D3D_SetSleepMode) && o_NvAPI_D3D_SetSleepMode) { + return &hkNvAPI_D3D_SetSleepMode; + } + if (InterfaceId == GET_ID(NvAPI_D3D_Sleep) && o_NvAPI_D3D_Sleep) { + return &hkNvAPI_D3D_Sleep; + } + if (InterfaceId == GET_ID(NvAPI_D3D_GetLatency) && o_NvAPI_D3D_GetLatency) { + return &hkNvAPI_D3D_GetLatency; + } + if (InterfaceId == GET_ID(NvAPI_D3D_SetLatencyMarker) && o_NvAPI_D3D_SetLatencyMarker) { + return &hkNvAPI_D3D_SetLatencyMarker; + } + if (InterfaceId == GET_ID(NvAPI_D3D12_SetAsyncFrameMarker) && o_NvAPI_D3D12_SetAsyncFrameMarker) { + return &hkNvAPI_D3D12_SetAsyncFrameMarker; + } + + return nullptr; +} + +// For updating information about Reflex hooks +void ReflexHooks::update(bool optiFg_FgState) { + // We can still use just the markers to limit the fps with Reflex disabled + // But need to fallback in case a game stops sending them for some reason + _updatesWithoutMarker++; + + State::Instance().reflexShowWarning = false; + + if (_updatesWithoutMarker > 20 || !_inited) + { + State::Instance().reflexLimitsFps = false; + return; + } + + // Don't use when: Real Reflex markers + OptiFG + Reflex disabled, causes huge input latency + State::Instance().reflexLimitsFps = fakenvapi::isUsingFakenvapi() || !optiFg_FgState || _lastSleepParams.bLowLatencyMode; + State::Instance().reflexShowWarning = !fakenvapi::isUsingFakenvapi() && optiFg_FgState && _lastSleepParams.bLowLatencyMode; + static float lastFps = 0; + static bool lastReflexLimitsFps = State::Instance().reflexLimitsFps; + + // Reset required when toggling Reflex + if (State::Instance().reflexLimitsFps != lastReflexLimitsFps) + { + lastReflexLimitsFps = State::Instance().reflexLimitsFps; + lastFps = 0; + setFPSLimit(0); + } + + if (!State::Instance().reflexLimitsFps) + return; + + float currentFps = Config::Instance()->FramerateLimit.value_or_default(); + static bool lastDlssgDetectedState = false; + + if (lastDlssgDetectedState != _dlssgDetected) + { + lastDlssgDetectedState = _dlssgDetected; + setFPSLimit(currentFps); + + if (_dlssgDetected) + LOG_DEBUG("DLSS FG detected"); + else + LOG_DEBUG("DLSS FG no longer detected"); + } + + if (optiFg_FgState || (_dlssgDetected && fakenvapi::isUsingFakenvapi())) + currentFps /= 2; + + if (currentFps != lastFps) { + setFPSLimit(currentFps); + lastFps = currentFps; + } +} + +// 0 - disables the fps cap +void ReflexHooks::setFPSLimit(float fps) { + LOG_INFO("Set FPS Limit to: {}", fps); + if (fps == 0.0) + _minimumIntervalUs = 0; + else + _minimumIntervalUs = static_cast(std::round(1'000'000 / fps)); + + if (_lastSleepDev != nullptr) { + NV_SET_SLEEP_MODE_PARAMS temp{}; + memcpy(&temp, &_lastSleepParams, sizeof(NV_SET_SLEEP_MODE_PARAMS)); + temp.minimumIntervalUs = _minimumIntervalUs; + o_NvAPI_D3D_SetSleepMode(_lastSleepDev, &temp); + } + +} \ No newline at end of file diff --git a/OptiScaler/nvapi/ReflexHooks.h b/OptiScaler/nvapi/ReflexHooks.h index 4d46fd12..72978375 100644 --- a/OptiScaler/nvapi/ReflexHooks.h +++ b/OptiScaler/nvapi/ReflexHooks.h @@ -1,7 +1,6 @@ #pragma once -#include -#include "fakenvapi.h" +#include #include "NvApiTypes.h" class ReflexHooks { @@ -19,213 +18,21 @@ class ReflexHooks { inline static decltype(&NvAPI_D3D_SetLatencyMarker) o_NvAPI_D3D_SetLatencyMarker = nullptr; inline static decltype(&NvAPI_D3D12_SetAsyncFrameMarker) o_NvAPI_D3D12_SetAsyncFrameMarker = nullptr; - inline static NvAPI_Status hNvAPI_D3D_SetSleepMode(IUnknown* pDev, NV_SET_SLEEP_MODE_PARAMS* pSetSleepModeParams) { -#ifdef _DEBUG - LOG_FUNC(); -#endif - // Store for later so we can adjust the fps whenever we want - memcpy(&_lastSleepParams, pSetSleepModeParams, sizeof(NV_SET_SLEEP_MODE_PARAMS)); - _lastSleepDev = pDev; - - if (_minimumIntervalUs != 0) - pSetSleepModeParams->minimumIntervalUs = _minimumIntervalUs; - - return o_NvAPI_D3D_SetSleepMode(pDev, pSetSleepModeParams); - } - - inline static NvAPI_Status hNvAPI_D3D_Sleep(IUnknown* pDev) { -#ifdef _DEBUG - LOG_FUNC(); -#endif - - return o_NvAPI_D3D_Sleep(pDev); - } - - inline static NvAPI_Status hNvAPI_D3D_GetLatency(IUnknown* pDev, NV_LATENCY_RESULT_PARAMS* pGetLatencyParams) { -#ifdef _DEBUG - LOG_FUNC(); -#endif - - return o_NvAPI_D3D_GetLatency(pDev, pGetLatencyParams); - } - - inline static NvAPI_Status hNvAPI_D3D_SetLatencyMarker(IUnknown* pDev, NV_LATENCY_MARKER_PARAMS* pSetLatencyMarkerParams) { -#ifdef _DEBUG - LOG_FUNC(); -#endif - _updatesWithoutMarker = 0; - - // Some games just stop sending any async markers when DLSSG is disabled, so a reset is needed - if (_lastAsyncMarkerFrameId + 10 < pSetLatencyMarkerParams->frameID) - _dlssgDetected = false; - - return o_NvAPI_D3D_SetLatencyMarker(pDev, pSetLatencyMarkerParams); - } - - inline static NvAPI_Status hNvAPI_D3D12_SetAsyncFrameMarker(ID3D12CommandQueue* pCommandQueue, NV_ASYNC_FRAME_MARKER_PARAMS* pSetAsyncFrameMarkerParams) { -#ifdef _DEBUG - LOG_FUNC(); -#endif - - _lastAsyncMarkerFrameId = pSetAsyncFrameMarkerParams->frameID; - - if (pSetAsyncFrameMarkerParams->markerType == OUT_OF_BAND_PRESENT_START) { - constexpr size_t history_size = 12; - static size_t counter = 0; - static NvU64 previous_frame_ids[history_size] = {}; - - previous_frame_ids[counter % history_size] = pSetAsyncFrameMarkerParams->frameID; - counter++; - - int repeat_count = 0; - - for (size_t i = 1; i < history_size; i++) { - // won't catch repeat frame ids across array wrap around - if (previous_frame_ids[i] == previous_frame_ids[i - 1]) { - repeat_count++; - } - } - - if (_dlssgDetected && repeat_count == 0) { - _dlssgDetected = false; - LOG_DEBUG("DLSS FG no longer detected"); - } - else if (!_dlssgDetected && repeat_count >= history_size / 2 - 1) { - _dlssgDetected = true; - LOG_DEBUG("DLSS FG detected"); - } - } - - return o_NvAPI_D3D12_SetAsyncFrameMarker(pCommandQueue, pSetAsyncFrameMarkerParams); - } + static NvAPI_Status hkNvAPI_D3D_SetSleepMode(IUnknown* pDev, NV_SET_SLEEP_MODE_PARAMS* pSetSleepModeParams); + static NvAPI_Status hkNvAPI_D3D_Sleep(IUnknown* pDev); + static NvAPI_Status hkNvAPI_D3D_GetLatency(IUnknown* pDev, NV_LATENCY_RESULT_PARAMS* pGetLatencyParams); + static NvAPI_Status hkNvAPI_D3D_SetLatencyMarker(IUnknown* pDev, NV_LATENCY_MARKER_PARAMS* pSetLatencyMarkerParams); + static NvAPI_Status hkNvAPI_D3D12_SetAsyncFrameMarker(ID3D12CommandQueue* pCommandQueue, NV_ASYNC_FRAME_MARKER_PARAMS* pSetAsyncFrameMarkerParams); public: - inline static void hookReflex(NvApiTypes::PFN_NvApi_QueryInterface& queryInterface) { -#ifdef _DEBUG - LOG_FUNC(); -#endif - - if (!_inited) { - o_NvAPI_D3D_SetSleepMode = static_cast(queryInterface(NvApiTypes::NV_INTERFACE::D3D_SetSleepMode)); - o_NvAPI_D3D_Sleep = static_cast(queryInterface(NvApiTypes::NV_INTERFACE::D3D_Sleep)); - o_NvAPI_D3D_GetLatency = static_cast(queryInterface(NvApiTypes::NV_INTERFACE::D3D_GetLatency)); - o_NvAPI_D3D_SetLatencyMarker = static_cast(queryInterface(NvApiTypes::NV_INTERFACE::D3D_SetLatencyMarker)); - o_NvAPI_D3D12_SetAsyncFrameMarker = static_cast(queryInterface(NvApiTypes::NV_INTERFACE::D3D12_SetAsyncFrameMarker)); - - _inited = o_NvAPI_D3D_SetSleepMode && o_NvAPI_D3D_Sleep && o_NvAPI_D3D_GetLatency && o_NvAPI_D3D_SetLatencyMarker && o_NvAPI_D3D12_SetAsyncFrameMarker; - - if (_inited) - LOG_DEBUG("Inited Reflex hooks"); - } - } - - inline static bool isDlssgDetected() - { - return _dlssgDetected; - } - - inline static bool isReflexHooked() - { - return _inited; - } - - inline static void* getHookedReflex(NvApiTypes::NV_INTERFACE InterfaceId) { - switch (InterfaceId) { - case NvApiTypes::NV_INTERFACE::D3D_SetSleepMode: - if (o_NvAPI_D3D_SetSleepMode != nullptr) - return &hNvAPI_D3D_SetSleepMode; - break; - case NvApiTypes::NV_INTERFACE::D3D_Sleep: - if (o_NvAPI_D3D_Sleep != nullptr) - return &hNvAPI_D3D_Sleep; - break; - case NvApiTypes::NV_INTERFACE::D3D_GetLatency: - if (o_NvAPI_D3D_GetLatency != nullptr) - return &hNvAPI_D3D_GetLatency; - break; - case NvApiTypes::NV_INTERFACE::D3D_SetLatencyMarker: - if (o_NvAPI_D3D_SetLatencyMarker != nullptr) - return &hNvAPI_D3D_SetLatencyMarker; - break; - case NvApiTypes::NV_INTERFACE::D3D12_SetAsyncFrameMarker: - if (o_NvAPI_D3D12_SetAsyncFrameMarker != nullptr) - return &hNvAPI_D3D12_SetAsyncFrameMarker; - break; - default: - break; - } - - return nullptr; - } + static void hookReflex(PFN_NvApi_QueryInterface& queryInterface); + static bool isDlssgDetected(); + static bool isReflexHooked(); + static void* getHookedReflex(unsigned int InterfaceId); // For updating information about Reflex hooks - inline static void update(bool optiFg_FgState) { - // We can still use just the markers to limit the fps with Reflex disabled - // But need to fallback in case a game stops sending them for some reason - _updatesWithoutMarker++; - - State::Instance().reflexShowWarning = false; - - if (_updatesWithoutMarker > 20 || !_inited) - { - State::Instance().reflexLimitsFps = false; - return; - } - - // Don't use when: Real Reflex markers + OptiFG + Reflex disabled, causes huge input latency - State::Instance().reflexLimitsFps = fakenvapi::isUsingFakenvapi() || !optiFg_FgState || _lastSleepParams.bLowLatencyMode; - State::Instance().reflexShowWarning = !fakenvapi::isUsingFakenvapi() && optiFg_FgState && _lastSleepParams.bLowLatencyMode; - static float lastFps = 0; - static bool lastReflexLimitsFps = State::Instance().reflexLimitsFps; - - // Reset required when toggling Reflex - if (State::Instance().reflexLimitsFps != lastReflexLimitsFps) - { - lastReflexLimitsFps = State::Instance().reflexLimitsFps; - lastFps = 0; - setFPSLimit(0); - } - - if (!State::Instance().reflexLimitsFps) - return; - - float currentFps = Config::Instance()->FramerateLimit.value_or_default(); - static bool lastDlssgDetectedState = false; - - if (lastDlssgDetectedState != _dlssgDetected) - { - lastDlssgDetectedState = _dlssgDetected; - setFPSLimit(currentFps); - - if (_dlssgDetected) - LOG_DEBUG("DLSS FG detected"); - else - LOG_DEBUG("DLSS FG no longer detected"); - } - - if (optiFg_FgState || (_dlssgDetected && fakenvapi::isUsingFakenvapi())) - currentFps /= 2; - - if (currentFps != lastFps) { - setFPSLimit(currentFps); - lastFps = currentFps; - } - } + static void update(bool optiFg_FgState); // 0 - disables the fps cap - inline static void setFPSLimit(float fps) { - LOG_INFO("Set FPS Limit to: {}", fps); - if (fps == 0.0) - _minimumIntervalUs = 0; - else - _minimumIntervalUs = static_cast(std::round(1'000'000 / fps)); - - if (_lastSleepDev != nullptr) { - NV_SET_SLEEP_MODE_PARAMS temp{}; - memcpy(&temp, &_lastSleepParams, sizeof(NV_SET_SLEEP_MODE_PARAMS)); - temp.minimumIntervalUs = _minimumIntervalUs; - o_NvAPI_D3D_SetSleepMode(_lastSleepDev, &temp); - } - - } + inline static void setFPSLimit(float fps); }; \ No newline at end of file diff --git a/OptiScaler/nvapi/fakenvapi.cpp b/OptiScaler/nvapi/fakenvapi.cpp new file mode 100644 index 00000000..b7128ba4 --- /dev/null +++ b/OptiScaler/nvapi/fakenvapi.cpp @@ -0,0 +1,64 @@ +#include "fakenvapi.h" +#include "proxies/FfxApi_Proxy.h" + +void fakenvapi::Init(PFN_NvApi_QueryInterface& queryInterface) { + if (_inited) return; + + LOG_INFO("Trying to get fakenvapi-specific functions"); + + Fake_InformFGState = static_cast(queryInterface(GET_ID(Fake_InformFGState))); + Fake_InformPresentFG = static_cast(queryInterface(GET_ID(Fake_InformPresentFG))); + Fake_GetAntiLagCtx = static_cast(queryInterface(GET_ID(Fake_GetAntiLagCtx))); + + if (Fake_InformFGState == nullptr) + LOG_INFO("Couldn't get InformFGState"); + if (Fake_InformPresentFG == nullptr) + LOG_INFO("Couldn't get InformPresentFG"); + if (Fake_GetAntiLagCtx == nullptr) + LOG_INFO("Couldn't get GetAntiLagCtx"); + + _inited = true; +} + +// Inform AntiLag 2 when present of interpolated frames starts +void fakenvapi::reportFGPresent(IDXGISwapChain* pSwapChain, bool fg_state, bool frame_interpolated) { + if (!Fake_InformFGState || !Fake_InformPresentFG) return; + + // Lets fakenvapi log and reset correctly + Fake_InformFGState(fg_state); + + if (fg_state) { + // Starting with FSR 3.1.1 we can provide an AntiLag 2 context to FSR FG + // and it will call SetFrameGenFrameType for us + auto static ffxApiVersion = FfxApiProxy::VersionDx12(); + constexpr feature_version requiredVersion = { 3, 1, 1 }; + if (isVersionOrBetter(ffxApiVersion, requiredVersion) && Fake_GetAntiLagCtx != nullptr) { + void* antilag2Context = nullptr; + Fake_GetAntiLagCtx(&antilag2Context); + LOG_TRACE("Fake_GetAntiLagCtx: {}", antilag2Context != nullptr); + + if (antilag2Context != nullptr) { + antilag2_data.context = antilag2Context; + antilag2_data.enabled = true; + + pSwapChain->SetPrivateData(IID_IFfxAntiLag2Data, sizeof(antilag2_data), &antilag2_data); + } + } + else + { + // Tell fakenvapi to call SetFrameGenFrameType by itself + // Reflex frame id might get used in the future + LOG_TRACE("Fake_InformPresentFG: {}", frame_interpolated); + Fake_InformPresentFG(frame_interpolated, 0); + } + } + else { + // Remove it or other FG mods won't work with AL2 + pSwapChain->SetPrivateData(IID_IFfxAntiLag2Data, 0, nullptr); + } +} + +// won't work with older fakenvapi builds +bool fakenvapi::isUsingFakenvapi() { + return Fake_InformFGState || Fake_InformPresentFG || Fake_GetAntiLagCtx; +} \ No newline at end of file diff --git a/OptiScaler/nvapi/fakenvapi.h b/OptiScaler/nvapi/fakenvapi.h index 6a165a53..20c6845f 100644 --- a/OptiScaler/nvapi/fakenvapi.h +++ b/OptiScaler/nvapi/fakenvapi.h @@ -1,22 +1,10 @@ #pragma once -#include #include - -enum class FN_INTERFACE : uint32_t -{ - Fake_InformFGState = 0x21382138, - Fake_InformPresentFG = 0x21392139, - Fake_GetAntiLagCtx = 0x21402140 -}; - -using PFN_Fake_InformFGState = uint32_t(__stdcall*)(bool fg_state); -using PFN_Fake_InformPresentFG = uint32_t(__stdcall*)(bool frame_interpolated, uint64_t reflex_frame_id); -using PFN_Fake_GetAntiLagCtx = uint32_t(__stdcall*)(void* al2_context); +#include "NvApiTypes.h" class fakenvapi { -private: inline static struct AntiLag2Data { void* context; @@ -29,69 +17,9 @@ private: inline static bool _inited = false; public: - typedef void* (__stdcall* PFN_Fake_QueryInterface)(FN_INTERFACE InterfaceId); - inline static const GUID IID_IFfxAntiLag2Data = { 0x5083ae5b, 0x8070, 0x4fca, {0x8e, 0xe5, 0x35, 0x82, 0xdd, 0x36, 0x7d, 0x13} }; - inline static void Init(PFN_Fake_QueryInterface& queryInterface) { - if (_inited) return; - - LOG_INFO("Trying to get fakenvapi-specific functions"); - - Fake_InformFGState = static_cast(queryInterface(FN_INTERFACE::Fake_InformFGState)); - Fake_InformPresentFG = static_cast(queryInterface(FN_INTERFACE::Fake_InformPresentFG)); - Fake_GetAntiLagCtx = static_cast(queryInterface(FN_INTERFACE::Fake_GetAntiLagCtx)); - - if (Fake_InformFGState == nullptr) - LOG_INFO("Couldn't get InformFGState"); - if (Fake_InformPresentFG == nullptr) - LOG_INFO("Couldn't get InformPresentFG"); - if (Fake_GetAntiLagCtx == nullptr) - LOG_INFO("Couldn't get GetAntiLagCtx"); - - _inited = true; - } - - // Inform AntiLag 2 when present of interpolated frames starts - inline static void reportFGPresent(IDXGISwapChain* pSwapChain, bool fg_state, bool frame_interpolated) { - if (Fake_InformFGState == nullptr || Fake_InformPresentFG == nullptr) return; - - // Lets fakenvapi log and reset correctly - Fake_InformFGState(fg_state); - - if (fg_state) { - // Starting with FSR 3.1.1 we can provide an AntiLag 2 context to FSR FG - // and it will call SetFrameGenFrameType for us - auto static ffxApiVersion = FfxApiProxy::VersionDx12(); - constexpr feature_version requiredVersion = { 3, 1, 1 }; - if (isVersionOrBetter(ffxApiVersion, requiredVersion) && Fake_GetAntiLagCtx != nullptr) { - void* antilag2Context = nullptr; - Fake_GetAntiLagCtx(&antilag2Context); - LOG_TRACE("Fake_GetAntiLagCtx: {}", antilag2Context != nullptr); - - if (antilag2Context != nullptr) { - antilag2_data.context = antilag2Context; - antilag2_data.enabled = true; - - pSwapChain->SetPrivateData(IID_IFfxAntiLag2Data, sizeof(antilag2_data), &antilag2_data); - } - } - else - { - // Tell fakenvapi to call SetFrameGenFrameType by itself - // Reflex frame id might get used in the future - LOG_TRACE("Fake_InformPresentFG: {}", frame_interpolated); - Fake_InformPresentFG(frame_interpolated, 0); - } - } - else { - // Remove it or other FG mods won't work with AL2 - pSwapChain->SetPrivateData(IID_IFfxAntiLag2Data, 0, nullptr); - } - } - - // won't work with older fakenvapi builds - inline static bool isUsingFakenvapi() { - return Fake_InformFGState != nullptr || Fake_InformPresentFG != nullptr || Fake_GetAntiLagCtx != nullptr; - } -}; \ No newline at end of file + static void Init(PFN_NvApi_QueryInterface& queryInterface); + static void reportFGPresent(IDXGISwapChain* pSwapChain, bool fg_state, bool frame_interpolated); + static bool isUsingFakenvapi(); +}; diff --git a/OptiScaler/upscalers/fsr31/FSR31Feature_Dx11On12.h b/OptiScaler/upscalers/fsr31/FSR31Feature_Dx11On12.h index ecbc892c..778c541c 100644 --- a/OptiScaler/upscalers/fsr31/FSR31Feature_Dx11On12.h +++ b/OptiScaler/upscalers/fsr31/FSR31Feature_Dx11On12.h @@ -3,6 +3,7 @@ #include #include "dx12/ffx_api_dx12.h" +#include "proxies/FfxApi_Proxy.h" class FSR31FeatureDx11on12 : public FSR31Feature, public IFeature_Dx11wDx12 @@ -26,4 +27,4 @@ public: if (_context != nullptr) FfxApiProxy::D3D12_DestroyContext()(&_context, NULL); } -}; \ No newline at end of file +}; diff --git a/OptiScaler/upscalers/fsr31/FSR31Feature_Dx12.h b/OptiScaler/upscalers/fsr31/FSR31Feature_Dx12.h index 582f2dd8..23d3e9dd 100644 --- a/OptiScaler/upscalers/fsr31/FSR31Feature_Dx12.h +++ b/OptiScaler/upscalers/fsr31/FSR31Feature_Dx12.h @@ -3,6 +3,7 @@ #include #include "dx12/ffx_api_dx12.h" +#include "proxies/FfxApi_Proxy.h" class FSR31FeatureDx12 : public FSR31Feature, public IFeature_Dx12 { @@ -22,4 +23,4 @@ public: if(!State::Instance().isShuttingDown && _context != nullptr) FfxApiProxy::D3D12_DestroyContext()(&_context, NULL); } -}; \ No newline at end of file +}; diff --git a/OptiScaler/upscalers/fsr31/FSR31Feature_Vk.h b/OptiScaler/upscalers/fsr31/FSR31Feature_Vk.h index 72dab48c..45fb75eb 100644 --- a/OptiScaler/upscalers/fsr31/FSR31Feature_Vk.h +++ b/OptiScaler/upscalers/fsr31/FSR31Feature_Vk.h @@ -3,6 +3,7 @@ #include #include "vk/ffx_api_vk.h" +#include class FSR31FeatureVk : public FSR31Feature, public IFeature_Vk { diff --git a/external/nvapi/NvApiDriverSettings.h b/external/nvapi/NvApiDriverSettings.h new file mode 100644 index 00000000..3c4308a0 --- /dev/null +++ b/external/nvapi/NvApiDriverSettings.h @@ -0,0 +1,1322 @@ +/*********************************************************************************************************\ +|* *| +|* SPDX-FileCopyrightText: Copyright (c) 2019-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. *| +|* SPDX-License-Identifier: MIT *| +|* *| +|* Permission is hereby granted, free of charge, to any person obtaining a *| +|* copy of this software and associated documentation files (the "Software"), *| +|* to deal in the Software without restriction, including without limitation *| +|* the rights to use, copy, modify, merge, publish, distribute, sublicense, *| +|* and/or sell copies of the Software, and to permit persons to whom the *| +|* Software is furnished to do so, subject to the following conditions: *| +|* *| +|* The above copyright notice and this permission notice shall be included in *| +|* all copies or substantial portions of the Software. *| +|* *| +|* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *| +|* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *| +|* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *| +|* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *| +|* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *| +|* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *| +|* DEALINGS IN THE SOFTWARE. *| +|* *| +|* *| +\*********************************************************************************************************/ + +#ifndef _NVAPI_DRIVER_SETTINGS_H_ +#define _NVAPI_DRIVER_SETTINGS_H_ + +#define OGL_AA_LINE_GAMMA_STRING L"Antialiasing - Line gamma" +#define OGL_CPL_GDI_COMPATIBILITY_STRING L"OpenGL GDI compatibility" +#define OGL_CPL_PREFER_DXPRESENT_STRING L"Vulkan/OpenGL present method" +#define OGL_DEEP_COLOR_SCANOUT_STRING L"Deep color for 3D applications" +#define OGL_DEFAULT_SWAP_INTERVAL_STRING L"OpenGL default swap interval" +#define OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_STRING L"OpenGL default swap interval fraction" +#define OGL_DEFAULT_SWAP_INTERVAL_SIGN_STRING L"OpenGL default swap interval sign" +#define OGL_EVENT_LOG_SEVERITY_THRESHOLD_STRING L"Event Log Severity Threshold" +#define OGL_EXTENSION_STRING_VERSION_STRING L"Extension String version" +#define OGL_FORCE_BLIT_STRING L"Buffer-flipping mode" +#define OGL_FORCE_STEREO_STRING L"Force Stereo shuttering" +#define OGL_IMPLICIT_GPU_AFFINITY_STRING L"Preferred OpenGL GPU" +#define OGL_MAX_FRAMES_ALLOWED_STRING L"Maximum frames allowed" +#define OGL_OVERLAY_PIXEL_TYPE_STRING L"Exported Overlay pixel types" +#define OGL_OVERLAY_SUPPORT_STRING L"Enable overlay" +#define OGL_QUALITY_ENHANCEMENTS_STRING L"High level control of the rendering quality on OpenGL" +#define OGL_SINGLE_BACKDEPTH_BUFFER_STRING L"Unified back/depth buffer" +#define OGL_SLI_MULTICAST_STRING L"Enable NV_gpu_multicast extension" +#define OGL_THREAD_CONTROL_STRING L"Threaded optimization" +#define OGL_TMON_LEVEL_STRING L"Event Log Tmon Severity Threshold" +#define OGL_TRIPLE_BUFFER_STRING L"Triple buffering" +#define AA_BEHAVIOR_FLAGS_STRING L"Antialiasing - Behavior Flags" +#define AA_MODE_ALPHATOCOVERAGE_STRING L"Antialiasing - Transparency Multisampling" +#define AA_MODE_GAMMACORRECTION_STRING L"Antialiasing - Gamma correction" +#define AA_MODE_METHOD_STRING L"Antialiasing - Setting" +#define AA_MODE_REPLAY_STRING L"Antialiasing - Transparency Supersampling" +#define AA_MODE_SELECTOR_STRING L"Antialiasing - Mode" +#define AA_MODE_SELECTOR_SLIAA_STRING L"Antialiasing - SLI AA" +#define ANISO_MODE_LEVEL_STRING L"Anisotropic filtering setting" +#define ANISO_MODE_SELECTOR_STRING L"Anisotropic filtering mode" +#define ANSEL_ALLOW_STRING L"NVIDIA Predefined Ansel Usage" +#define ANSEL_ALLOWLISTED_STRING L"Ansel flags for enabled applications" +#define ANSEL_ENABLE_STRING L"Enable Ansel" +#define APPIDLE_DYNAMIC_FRL_FPS_STRING L"Idle Application Max FPS Limit" +#define APPIDLE_DYNAMIC_FRL_THRESHOLD_TIME_STRING L"Idle Application Threshold Time out in seconds" +#define APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_STRING L"Application Profile Notification Popup Timeout" +#define APPLICATION_STEAM_ID_STRING L"Steam Application ID" +#define BATTERY_BOOST_APP_FPS_STRING L"Battery Boost Application FPS" +#define CPL_HIDDEN_PROFILE_STRING L"Do not display this profile in the Control Panel" +#define CUDA_EXCLUDED_GPUS_STRING L"List of Universal GPU ids" +#define D3DOGL_GPU_MAX_POWER_STRING L"Maximum GPU Power" +#define EXPORT_PERF_COUNTERS_STRING L"Export Performance Counters" +#define EXTERNAL_QUIET_MODE_STRING L"External Quiet Mode (XQM)" +#define FRL_FPS_STRING L"Frame Rate Limiter" +#define FXAA_ALLOW_STRING L"NVIDIA Predefined FXAA Usage" +#define FXAA_ENABLE_STRING L"Enable FXAA" +#define FXAA_INDICATOR_ENABLE_STRING L"Enable FXAA Indicator" +#define LATENCY_INDICATOR_AUTOALIGN_STRING L"Autoalign flash indicator" +#define MCSFRSHOWSPLIT_STRING L"SLI indicator" +#define NGX_DLAA_OVERRIDE_STRING L"Override DLSS mode to be DLAA" +#define NGX_DLSSG_MULTI_FRAME_COUNT_STRING L"Override DLSSG multi-frame count" +#define NGX_DLSS_FG_OVERRIDE_STRING L"Enable DLSS-FG override" +#define NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_STRING L"Override reserved key 1 for FG" +#define NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_STRING L"Override reserved key 2 for FG" +#define NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_STRING L"Override DLSS performance mode to be ultra-perfomance" +#define NGX_DLSS_RR_MODE_STRING L"Override DLSS-RR performance mode" +#define NGX_DLSS_RR_OVERRIDE_STRING L"Enable DLSS-RR override" +#define NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_STRING L"Override DLSS-RR preset" +#define NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_STRING L"Override reserved key 1 for RR" +#define NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_STRING L"Override reserved key 2 for RR" +#define NGX_DLSS_SR_MODE_STRING L"Override DLSS-SR performance mode" +#define NGX_DLSS_SR_OVERRIDE_STRING L"Enable DLSS-SR override" +#define NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_STRING L"Override DLSS-SR presets" +#define NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_STRING L"Override reserved key 1 for SR" +#define NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_STRING L"Override reserved key 2 for SR" +#define NV_QUALITY_UPSCALING_STRING L"NVIDIA Quality upscaling" +#define OPTIMUS_MAXAA_STRING L"Maximum AA samples allowed for a given application" +#define PHYSXINDICATOR_STRING L"Display the PhysX indicator" +#define PREFERRED_PSTATE_STRING L"Power management mode" +#define PREVENT_UI_AF_OVERRIDE_STRING L"No override of Anisotropic filtering" +#define SHIM_MAXRES_STRING L"Maximum resolution allowed for a given application" +#define SHIM_MCCOMPAT_STRING L"Optimus flags for enabled applications" +#define SHIM_RENDERING_MODE_STRING L"Enable application for Optimus" +#define SHIM_RENDERING_OPTIONS_STRING L"Shim Rendering Mode Options per application for Optimus" +#define SLI_GPU_COUNT_STRING L"Number of GPUs to use on SLI rendering mode" +#define SLI_PREDEFINED_GPU_COUNT_STRING L"NVIDIA predefined number of GPUs to use on SLI rendering mode" +#define SLI_PREDEFINED_GPU_COUNT_DX10_STRING L"NVIDIA predefined number of GPUs to use on SLI rendering mode on DirectX 10" +#define SLI_PREDEFINED_MODE_STRING L"NVIDIA predefined SLI mode" +#define SLI_PREDEFINED_MODE_DX10_STRING L"NVIDIA predefined SLI mode on DirectX 10" +#define SLI_RENDERING_MODE_STRING L"SLI rendering mode" +#define VRPRERENDERLIMIT_STRING L"Virtual Reality pre-rendered frames" +#define VRRFEATUREINDICATOR_STRING L"Toggle the VRR global feature" +#define VRROVERLAYINDICATOR_STRING L"Display the VRR Overlay Indicator" +#define VRRREQUESTSTATE_STRING L"VRR requested state" +#define VRR_APP_OVERRIDE_STRING L"G-SYNC" +#define VRR_APP_OVERRIDE_REQUEST_STATE_STRING L"G-SYNC" +#define VRR_MODE_STRING L"Enable G-SYNC globally" +#define VSYNCSMOOTHAFR_STRING L"Flag to control smooth AFR behavior" +#define VSYNCVRRCONTROL_STRING L"Variable refresh Rate" +#define VSYNC_BEHAVIOR_FLAGS_STRING L"Vsync - Behavior Flags" +#define WKS_API_STEREO_EYES_EXCHANGE_STRING L"Stereo - Swap eyes" +#define WKS_API_STEREO_MODE_STRING L"Stereo - Display mode" +#define WKS_STEREO_DONGLE_SUPPORT_STRING L"Stereo - Dongle Support" +#define WKS_STEREO_SUPPORT_STRING L"Stereo - Enable" +#define WKS_STEREO_SWAP_MODE_STRING L"Stereo - swap mode" +#define AO_MODE_STRING L"Ambient Occlusion" +#define AO_MODE_ACTIVE_STRING L"NVIDIA Predefined Ambient Occlusion Usage" +#define AUTO_LODBIASADJUST_STRING L"Texture filtering - Driver Controlled LOD Bias" +#define EXPORT_PERF_COUNTERS_DX9_ONLY_STRING L"Export Performance Counters for DX9 only" +#define ICAFE_LOGO_CONFIG_STRING L"ICafe Settings" +#define LODBIASADJUST_STRING L"Texture filtering - LOD Bias" +#define MAXWELL_B_SAMPLE_INTERLEAVE_STRING L"Enable sample interleaving (MFAA)" +#define PRERENDERLIMIT_STRING L"Maximum pre-rendered frames" +#define PS_SHADERDISKCACHE_STRING L"Shader Cache" +#define PS_SHADERDISKCACHE_DLL_PATH_WCHAR_STRING L"shader cache path to dll" +#define PS_SHADERDISKCACHE_MAX_SIZE_STRING L"Shader disk cache maximum size" +#define PS_TEXFILTER_ANISO_OPTS2_STRING L"Texture filtering - Anisotropic sample optimization" +#define PS_TEXFILTER_BILINEAR_IN_ANISO_STRING L"Texture filtering - Anisotropic filter optimization" +#define PS_TEXFILTER_DISABLE_TRILIN_SLOPE_STRING L"Texture filtering - Trilinear optimization" +#define PS_TEXFILTER_NO_NEG_LODBIAS_STRING L"Texture filtering - Negative LOD bias" +#define QUALITY_ENHANCEMENTS_STRING L"Texture filtering - Quality" +#define QUALITY_ENHANCEMENT_SUBSTITUTION_STRING L"Texture filtering - Quality Substitution" +#define REFRESH_RATE_OVERRIDE_STRING L"Preferred refresh rate" +#define SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_STRING L"PowerThrottle" +#define SET_VAB_DATA_STRING L"VAB Default Data" +#define VSYNCMODE_STRING L"Vertical Sync" +#define VSYNCTEARCONTROL_STRING L"Vertical Sync Tear Control" + +enum ESetting { + OGL_AA_LINE_GAMMA_ID = 0x2089BF6C, + OGL_CPL_GDI_COMPATIBILITY_ID = 0x2072C5A3, + OGL_CPL_PREFER_DXPRESENT_ID = 0x20D690F8, + OGL_DEEP_COLOR_SCANOUT_ID = 0x2097C2F6, + OGL_DEFAULT_SWAP_INTERVAL_ID = 0x206A6582, + OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_ID = 0x206C4581, + OGL_DEFAULT_SWAP_INTERVAL_SIGN_ID = 0x20655CFA, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_ID = 0x209DF23E, + OGL_EXTENSION_STRING_VERSION_ID = 0x20FF7493, + OGL_FORCE_BLIT_ID = 0x201F619F, + OGL_FORCE_STEREO_ID = 0x204D9A0C, + OGL_IMPLICIT_GPU_AFFINITY_ID = 0x20D0F3E6, + OGL_MAX_FRAMES_ALLOWED_ID = 0x208E55E3, + OGL_OVERLAY_PIXEL_TYPE_ID = 0x209AE66F, + OGL_OVERLAY_SUPPORT_ID = 0x206C28C4, + OGL_QUALITY_ENHANCEMENTS_ID = 0x20797D6C, + OGL_SINGLE_BACKDEPTH_BUFFER_ID = 0x20A29055, + OGL_SLI_MULTICAST_ID = 0x2092D3BE, + OGL_THREAD_CONTROL_ID = 0x20C1221E, + OGL_TMON_LEVEL_ID = 0x202888C1, + OGL_TRIPLE_BUFFER_ID = 0x20FDD1F9, + AA_BEHAVIOR_FLAGS_ID = 0x10ECDB82, + AA_MODE_ALPHATOCOVERAGE_ID = 0x10FC2D9C, + AA_MODE_GAMMACORRECTION_ID = 0x107D639D, + AA_MODE_METHOD_ID = 0x10D773D2, + AA_MODE_REPLAY_ID = 0x10D48A85, + AA_MODE_SELECTOR_ID = 0x107EFC5B, + AA_MODE_SELECTOR_SLIAA_ID = 0x107AFC5B, + ANISO_MODE_LEVEL_ID = 0x101E61A9, + ANISO_MODE_SELECTOR_ID = 0x10D2BB16, + ANSEL_ALLOW_ID = 0x1035DB89, + ANSEL_ALLOWLISTED_ID = 0x1085DA8A, + ANSEL_ENABLE_ID = 0x1075D972, + APPIDLE_DYNAMIC_FRL_FPS_ID = 0x10835016, + APPIDLE_DYNAMIC_FRL_THRESHOLD_TIME_ID = 0x10835017, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_ID = 0x104554B6, + APPLICATION_STEAM_ID_ID = 0x107CDDBC, + BATTERY_BOOST_APP_FPS_ID = 0x10115C8C, + CPL_HIDDEN_PROFILE_ID = 0x106D5CFF, + CUDA_EXCLUDED_GPUS_ID = 0x10354FF8, + D3DOGL_GPU_MAX_POWER_ID = 0x10D1EF29, + EXPORT_PERF_COUNTERS_ID = 0x108F0841, + EXTERNAL_QUIET_MODE_ID = 0x10115C8D, + FRL_FPS_ID = 0x10835002, + FXAA_ALLOW_ID = 0x1034CB89, + FXAA_ENABLE_ID = 0x1074C972, + FXAA_INDICATOR_ENABLE_ID = 0x1068FB9C, + LATENCY_INDICATOR_AUTOALIGN_ID = 0x1095F170, + MCSFRSHOWSPLIT_ID = 0x10287051, + NGX_DLAA_OVERRIDE_ID = 0x10E41DF4, + NGX_DLSSG_MULTI_FRAME_COUNT_ID = 0x104D6667, + NGX_DLSS_FG_OVERRIDE_ID = 0x10E41E03, + NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_ID = 0x10C7D57E, + NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_ID = 0x10C7D519, + NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_ID = 0x10AFB76C, + NGX_DLSS_RR_MODE_ID = 0x10BD9423, + NGX_DLSS_RR_OVERRIDE_ID = 0x10E41E02, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_ID = 0x10E41DF7, + NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_ID = 0x10C7D86C, + NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_ID = 0x10C7D597, + NGX_DLSS_SR_MODE_ID = 0x10AFB768, + NGX_DLSS_SR_OVERRIDE_ID = 0x10E41E01, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_ID = 0x10E41DF3, + NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_ID = 0x10C7D684, + NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_ID = 0x10C7D82C, + NV_QUALITY_UPSCALING_ID = 0x10444444, + OPTIMUS_MAXAA_ID = 0x10F9DC83, + PHYSXINDICATOR_ID = 0x1094F16F, + PREFERRED_PSTATE_ID = 0x1057EB71, + PREVENT_UI_AF_OVERRIDE_ID = 0x103BCCB5, + SHIM_MAXRES_ID = 0x10F9DC82, + SHIM_MCCOMPAT_ID = 0x10F9DC80, + SHIM_RENDERING_MODE_ID = 0x10F9DC81, + SHIM_RENDERING_OPTIONS_ID = 0x10F9DC84, + SLI_GPU_COUNT_ID = 0x1033DCD1, + SLI_PREDEFINED_GPU_COUNT_ID = 0x1033DCD2, + SLI_PREDEFINED_GPU_COUNT_DX10_ID = 0x1033DCD3, + SLI_PREDEFINED_MODE_ID = 0x1033CEC1, + SLI_PREDEFINED_MODE_DX10_ID = 0x1033CEC2, + SLI_RENDERING_MODE_ID = 0x1033CED1, + VRPRERENDERLIMIT_ID = 0x10111133, + VRRFEATUREINDICATOR_ID = 0x1094F157, + VRROVERLAYINDICATOR_ID = 0x1095F16F, + VRRREQUESTSTATE_ID = 0x1094F1F7, + VRR_APP_OVERRIDE_ID = 0x10A879CF, + VRR_APP_OVERRIDE_REQUEST_STATE_ID = 0x10A879AC, + VRR_MODE_ID = 0x1194F158, + VSYNCSMOOTHAFR_ID = 0x101AE763, + VSYNCVRRCONTROL_ID = 0x10A879CE, + VSYNC_BEHAVIOR_FLAGS_ID = 0x10FDEC23, + WKS_API_STEREO_EYES_EXCHANGE_ID = 0x11AE435C, + WKS_API_STEREO_MODE_ID = 0x11E91A61, + WKS_STEREO_DONGLE_SUPPORT_ID = 0x112493BD, + WKS_STEREO_SUPPORT_ID = 0x11AA9E99, + WKS_STEREO_SWAP_MODE_ID = 0x11333333, + AO_MODE_ID = 0x00667329, + AO_MODE_ACTIVE_ID = 0x00664339, + AUTO_LODBIASADJUST_ID = 0x00638E8F, + EXPORT_PERF_COUNTERS_DX9_ONLY_ID = 0x00B65E72, + ICAFE_LOGO_CONFIG_ID = 0x00DB1337, + LODBIASADJUST_ID = 0x00738E8F, + MAXWELL_B_SAMPLE_INTERLEAVE_ID = 0x0098C1AC, + PRERENDERLIMIT_ID = 0x007BA09E, + PS_SHADERDISKCACHE_ID = 0x00198FFF, + PS_SHADERDISKCACHE_DLL_PATH_WCHAR_ID = 0x0019A002, + PS_SHADERDISKCACHE_MAX_SIZE_ID = 0x00AC8497, + PS_TEXFILTER_ANISO_OPTS2_ID = 0x00E73211, + PS_TEXFILTER_BILINEAR_IN_ANISO_ID = 0x0084CD70, + PS_TEXFILTER_DISABLE_TRILIN_SLOPE_ID = 0x002ECAF2, + PS_TEXFILTER_NO_NEG_LODBIAS_ID = 0x0019BB68, + QUALITY_ENHANCEMENTS_ID = 0x00CE2691, + QUALITY_ENHANCEMENT_SUBSTITUTION_ID = 0x00CE2692, + REFRESH_RATE_OVERRIDE_ID = 0x0064B541, + SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_ID = 0x00AE785C, + SET_VAB_DATA_ID = 0x00AB8687, + VSYNCMODE_ID = 0x00A879CF, + VSYNCTEARCONTROL_ID = 0x005A375C, + TOTAL_DWORD_SETTING_NUM = 112, + TOTAL_WSTRING_SETTING_NUM = 5, + TOTAL_SETTING_NUM = 117, + INVALID_SETTING_ID = 0xFFFFFFFF +}; + +enum EValues_OGL_AA_LINE_GAMMA { + OGL_AA_LINE_GAMMA_DISABLED = 0x10, + OGL_AA_LINE_GAMMA_ENABLED = 0x23, + OGL_AA_LINE_GAMMA_MIN = 1, + OGL_AA_LINE_GAMMA_MAX = 100, + OGL_AA_LINE_GAMMA_NUM_VALUES = 4, + OGL_AA_LINE_GAMMA_DEFAULT = OGL_AA_LINE_GAMMA_DISABLED +}; + +enum EValues_OGL_CPL_GDI_COMPATIBILITY { + OGL_CPL_GDI_COMPATIBILITY_PREFER_DISABLED = 0x00000000, + OGL_CPL_GDI_COMPATIBILITY_PREFER_ENABLED = 0x00000001, + OGL_CPL_GDI_COMPATIBILITY_AUTO = 0x00000002, + OGL_CPL_GDI_COMPATIBILITY_NUM_VALUES = 3, + OGL_CPL_GDI_COMPATIBILITY_DEFAULT = OGL_CPL_GDI_COMPATIBILITY_AUTO +}; + +enum EValues_OGL_CPL_PREFER_DXPRESENT { + OGL_CPL_PREFER_DXPRESENT_PREFER_DISABLED = 0x00000000, + OGL_CPL_PREFER_DXPRESENT_PREFER_ENABLED = 0x00000001, + OGL_CPL_PREFER_DXPRESENT_AUTO = 0x00000002, + OGL_CPL_PREFER_DXPRESENT_NUM_VALUES = 3, + OGL_CPL_PREFER_DXPRESENT_DEFAULT = OGL_CPL_PREFER_DXPRESENT_AUTO +}; + +enum EValues_OGL_DEEP_COLOR_SCANOUT { + OGL_DEEP_COLOR_SCANOUT_DISABLE = 0, + OGL_DEEP_COLOR_SCANOUT_ENABLE = 1, + OGL_DEEP_COLOR_SCANOUT_NUM_VALUES = 2, + OGL_DEEP_COLOR_SCANOUT_DEFAULT = OGL_DEEP_COLOR_SCANOUT_ENABLE +}; + +enum EValues_OGL_DEFAULT_SWAP_INTERVAL { + OGL_DEFAULT_SWAP_INTERVAL_TEAR = 0, + OGL_DEFAULT_SWAP_INTERVAL_VSYNC_ONE = 1, + OGL_DEFAULT_SWAP_INTERVAL_VSYNC = 1, + OGL_DEFAULT_SWAP_INTERVAL_VALUE_MASK = 0x0000FFFF, + OGL_DEFAULT_SWAP_INTERVAL_FORCE_MASK = 0xF0000000, + OGL_DEFAULT_SWAP_INTERVAL_FORCE_OFF = 0xF0000000, + OGL_DEFAULT_SWAP_INTERVAL_FORCE_ON = 0x10000000, + OGL_DEFAULT_SWAP_INTERVAL_APP_CONTROLLED = 0x00000000, + OGL_DEFAULT_SWAP_INTERVAL_DISABLE = 0xffffffff, + OGL_DEFAULT_SWAP_INTERVAL_NUM_VALUES = 9, + OGL_DEFAULT_SWAP_INTERVAL_DEFAULT = OGL_DEFAULT_SWAP_INTERVAL_VSYNC_ONE +}; + +enum EValues_OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL { + OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_ZERO_SCANLINES = 0, + OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_ONE_FULL_FRAME_OF_SCANLINES = 100, + OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_NUM_VALUES = 2, + OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_DEFAULT = 0U +}; + +enum EValues_OGL_DEFAULT_SWAP_INTERVAL_SIGN { + OGL_DEFAULT_SWAP_INTERVAL_SIGN_POSITIVE = 0, + OGL_DEFAULT_SWAP_INTERVAL_SIGN_NEGATIVE = 1, + OGL_DEFAULT_SWAP_INTERVAL_SIGN_NUM_VALUES = 2, + OGL_DEFAULT_SWAP_INTERVAL_SIGN_DEFAULT = OGL_DEFAULT_SWAP_INTERVAL_SIGN_POSITIVE +}; + +enum EValues_OGL_EVENT_LOG_SEVERITY_THRESHOLD { + OGL_EVENT_LOG_SEVERITY_THRESHOLD_DISABLE = 0, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_CRITICAL = 1, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_WARNING = 2, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_INFORMATION = 3, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_ALL = 4, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_NUM_VALUES = 5, + OGL_EVENT_LOG_SEVERITY_THRESHOLD_DEFAULT = OGL_EVENT_LOG_SEVERITY_THRESHOLD_ALL +}; + +enum EValues_OGL_FORCE_BLIT { + OGL_FORCE_BLIT_ON = 1, + OGL_FORCE_BLIT_OFF = 0, + OGL_FORCE_BLIT_NUM_VALUES = 2, + OGL_FORCE_BLIT_DEFAULT = OGL_FORCE_BLIT_OFF +}; + +enum EValues_OGL_FORCE_STEREO { + OGL_FORCE_STEREO_OFF = 0, + OGL_FORCE_STEREO_ON = 1, + OGL_FORCE_STEREO_NUM_VALUES = 2, + OGL_FORCE_STEREO_DEFAULT = OGL_FORCE_STEREO_OFF +}; + +#define OGL_IMPLICIT_GPU_AFFINITY_ENV_VAR L"OGL_DEFAULT_RENDERING_GPU" +#define OGL_IMPLICIT_GPU_AFFINITY_AUTOSELECT L"autoselect" +#define OGL_IMPLICIT_GPU_AFFINITY_NUM_VALUES 1 +#define OGL_IMPLICIT_GPU_AFFINITY_DEFAULT OGL_IMPLICIT_GPU_AFFINITY_AUTOSELECT + +enum EValues_OGL_OVERLAY_PIXEL_TYPE { + OGL_OVERLAY_PIXEL_TYPE_NONE = 0x0, + OGL_OVERLAY_PIXEL_TYPE_CI = 0x1, + OGL_OVERLAY_PIXEL_TYPE_RGBA = 0x2, + OGL_OVERLAY_PIXEL_TYPE_CI_AND_RGBA = 0x3, + OGL_OVERLAY_PIXEL_TYPE_NUM_VALUES = 4, + OGL_OVERLAY_PIXEL_TYPE_DEFAULT = OGL_OVERLAY_PIXEL_TYPE_CI +}; + +enum EValues_OGL_OVERLAY_SUPPORT { + OGL_OVERLAY_SUPPORT_OFF = 0, + OGL_OVERLAY_SUPPORT_ON = 1, + OGL_OVERLAY_SUPPORT_FORCE_SW = 2, + OGL_OVERLAY_SUPPORT_NUM_VALUES = 3, + OGL_OVERLAY_SUPPORT_DEFAULT = OGL_OVERLAY_SUPPORT_OFF +}; + +enum EValues_OGL_QUALITY_ENHANCEMENTS { + OGL_QUALITY_ENHANCEMENTS_HQUAL = 0xfffffff6, + OGL_QUALITY_ENHANCEMENTS_QUAL = 0, + OGL_QUALITY_ENHANCEMENTS_PERF = 10, + OGL_QUALITY_ENHANCEMENTS_HPERF = 20, + OGL_QUALITY_ENHANCEMENTS_NUM_VALUES = 4, + OGL_QUALITY_ENHANCEMENTS_DEFAULT = OGL_QUALITY_ENHANCEMENTS_QUAL +}; + +enum EValues_OGL_SINGLE_BACKDEPTH_BUFFER { + OGL_SINGLE_BACKDEPTH_BUFFER_DISABLE = 0x0, + OGL_SINGLE_BACKDEPTH_BUFFER_ENABLE = 0x1, + OGL_SINGLE_BACKDEPTH_BUFFER_USE_HW_DEFAULT = 0xffffffff, + OGL_SINGLE_BACKDEPTH_BUFFER_NUM_VALUES = 3, + OGL_SINGLE_BACKDEPTH_BUFFER_DEFAULT = OGL_SINGLE_BACKDEPTH_BUFFER_DISABLE +}; + +enum EValues_OGL_SLI_MULTICAST { + OGL_SLI_MULTICAST_DISABLE = 0x00, + OGL_SLI_MULTICAST_ENABLE = 0x01, + OGL_SLI_MULTICAST_FORCE_DISABLE = 0x02, + OGL_SLI_MULTICAST_ALLOW_MOSAIC = 0x04, + OGL_SLI_MULTICAST_NUM_VALUES = 4, + OGL_SLI_MULTICAST_DEFAULT = OGL_SLI_MULTICAST_DISABLE +}; + +enum EValues_OGL_THREAD_CONTROL { + OGL_THREAD_CONTROL_ENABLE = 0x00000001, + OGL_THREAD_CONTROL_DISABLE = 0x00000002, + OGL_THREAD_CONTROL_NUM_VALUES = 2, + OGL_THREAD_CONTROL_DEFAULT = 0U +}; + +enum EValues_OGL_TMON_LEVEL { + OGL_TMON_LEVEL_DISABLE = 0, + OGL_TMON_LEVEL_CRITICAL = 1, + OGL_TMON_LEVEL_WARNING = 2, + OGL_TMON_LEVEL_INFORMATION = 3, + OGL_TMON_LEVEL_MOST = 4, + OGL_TMON_LEVEL_VERBOSE = 5, + OGL_TMON_LEVEL_NUM_VALUES = 6, + OGL_TMON_LEVEL_DEFAULT = OGL_TMON_LEVEL_MOST +}; + +enum EValues_OGL_TRIPLE_BUFFER { + OGL_TRIPLE_BUFFER_DISABLED = 0x00000000, + OGL_TRIPLE_BUFFER_ENABLED = 0x00000001, + OGL_TRIPLE_BUFFER_NUM_VALUES = 2, + OGL_TRIPLE_BUFFER_DEFAULT = OGL_TRIPLE_BUFFER_DISABLED +}; + +enum EValues_AA_BEHAVIOR_FLAGS { + AA_BEHAVIOR_FLAGS_NONE = 0x00000000, + AA_BEHAVIOR_FLAGS_TREAT_OVERRIDE_AS_APP_CONTROLLED = 0x00000001, + AA_BEHAVIOR_FLAGS_TREAT_OVERRIDE_AS_ENHANCE = 0x00000002, + AA_BEHAVIOR_FLAGS_DISABLE_OVERRIDE = 0x00000003, + AA_BEHAVIOR_FLAGS_TREAT_ENHANCE_AS_APP_CONTROLLED = 0x00000004, + AA_BEHAVIOR_FLAGS_TREAT_ENHANCE_AS_OVERRIDE = 0x00000008, + AA_BEHAVIOR_FLAGS_DISABLE_ENHANCE = 0x0000000c, + AA_BEHAVIOR_FLAGS_MAP_VCAA_TO_MULTISAMPLING = 0x00010000, + AA_BEHAVIOR_FLAGS_SLI_DISABLE_TRANSPARENCY_SUPERSAMPLING = 0x00020000, + AA_BEHAVIOR_FLAGS_DISABLE_CPLAA = 0x00040000, + AA_BEHAVIOR_FLAGS_SKIP_RT_DIM_CHECK_FOR_ENHANCE = 0x00080000, + AA_BEHAVIOR_FLAGS_DISABLE_SLIAA = 0x00100000, + AA_BEHAVIOR_FLAGS_DEFAULT = 0x00000000, + AA_BEHAVIOR_FLAGS_AA_RT_BPP_DIV_4 = 0xf0000000, + AA_BEHAVIOR_FLAGS_AA_RT_BPP_DIV_4_SHIFT = 28, + AA_BEHAVIOR_FLAGS_NON_AA_RT_BPP_DIV_4 = 0x0f000000, + AA_BEHAVIOR_FLAGS_NON_AA_RT_BPP_DIV_4_SHIFT = 24, + AA_BEHAVIOR_FLAGS_MASK = 0xff1f000f, + AA_BEHAVIOR_FLAGS_NUM_VALUES = 18, +}; + +enum EValues_AA_MODE_ALPHATOCOVERAGE { + AA_MODE_ALPHATOCOVERAGE_MODE_MASK = 0x00000004, + AA_MODE_ALPHATOCOVERAGE_MODE_OFF = 0x00000000, + AA_MODE_ALPHATOCOVERAGE_MODE_ON = 0x00000004, + AA_MODE_ALPHATOCOVERAGE_MODE_MAX = 0x00000004, + AA_MODE_ALPHATOCOVERAGE_NUM_VALUES = 4, + AA_MODE_ALPHATOCOVERAGE_DEFAULT = 0x00000000 +}; + +enum EValues_AA_MODE_GAMMACORRECTION { + AA_MODE_GAMMACORRECTION_MASK = 0x00000003, + AA_MODE_GAMMACORRECTION_OFF = 0x00000000, + AA_MODE_GAMMACORRECTION_ON_IF_FOS = 0x00000001, + AA_MODE_GAMMACORRECTION_ON_ALWAYS = 0x00000002, + AA_MODE_GAMMACORRECTION_MAX = 0x00000002, + AA_MODE_GAMMACORRECTION_DEFAULT = 0x00000000, + AA_MODE_GAMMACORRECTION_DEFAULT_TESLA = 0x00000002, + AA_MODE_GAMMACORRECTION_DEFAULT_FERMI = 0x00000002, + AA_MODE_GAMMACORRECTION_NUM_VALUES = 8, +}; + +enum EValues_AA_MODE_METHOD { + AA_MODE_METHOD_NONE = 0x0, + AA_MODE_METHOD_SUPERSAMPLE_2X_H = 0x1, + AA_MODE_METHOD_SUPERSAMPLE_2X_V = 0x2, + AA_MODE_METHOD_SUPERSAMPLE_1_5X1_5 = 0x2, + AA_MODE_METHOD_FREE_0x03 = 0x3, + AA_MODE_METHOD_FREE_0x04 = 0x4, + AA_MODE_METHOD_SUPERSAMPLE_4X = 0x5, + AA_MODE_METHOD_SUPERSAMPLE_4X_BIAS = 0x6, + AA_MODE_METHOD_SUPERSAMPLE_4X_GAUSSIAN = 0x7, + AA_MODE_METHOD_FREE_0x08 = 0x8, + AA_MODE_METHOD_FREE_0x09 = 0x9, + AA_MODE_METHOD_SUPERSAMPLE_9X = 0xA, + AA_MODE_METHOD_SUPERSAMPLE_9X_BIAS = 0xB, + AA_MODE_METHOD_SUPERSAMPLE_16X = 0xC, + AA_MODE_METHOD_SUPERSAMPLE_16X_BIAS = 0xD, + AA_MODE_METHOD_MULTISAMPLE_2X_DIAGONAL = 0xE, + AA_MODE_METHOD_MULTISAMPLE_2X_QUINCUNX = 0xF, + AA_MODE_METHOD_MULTISAMPLE_4X = 0x10, + AA_MODE_METHOD_FREE_0x11 = 0x11, + AA_MODE_METHOD_MULTISAMPLE_4X_GAUSSIAN = 0x12, + AA_MODE_METHOD_MIXEDSAMPLE_4X_SKEWED_4TAP = 0x13, + AA_MODE_METHOD_FREE_0x14 = 0x14, + AA_MODE_METHOD_FREE_0x15 = 0x15, + AA_MODE_METHOD_MIXEDSAMPLE_6X = 0x16, + AA_MODE_METHOD_MIXEDSAMPLE_6X_SKEWED_6TAP = 0x17, + AA_MODE_METHOD_MIXEDSAMPLE_8X = 0x18, + AA_MODE_METHOD_MIXEDSAMPLE_8X_SKEWED_8TAP = 0x19, + AA_MODE_METHOD_MIXEDSAMPLE_16X = 0x1a, + AA_MODE_METHOD_MULTISAMPLE_4X_GAMMA = 0x1b, + AA_MODE_METHOD_MULTISAMPLE_16X = 0x1c, + AA_MODE_METHOD_VCAA_32X_8v24 = 0x1d, + AA_MODE_METHOD_CORRUPTION_CHECK = 0x1e, + AA_MODE_METHOD_6X_CT = 0x1f, + AA_MODE_METHOD_MULTISAMPLE_2X_DIAGONAL_GAMMA = 0x20, + AA_MODE_METHOD_SUPERSAMPLE_4X_GAMMA = 0x21, + AA_MODE_METHOD_MULTISAMPLE_4X_FOSGAMMA = 0x22, + AA_MODE_METHOD_MULTISAMPLE_2X_DIAGONAL_FOSGAMMA = 0x23, + AA_MODE_METHOD_SUPERSAMPLE_4X_FOSGAMMA = 0x24, + AA_MODE_METHOD_MULTISAMPLE_8X = 0x25, + AA_MODE_METHOD_VCAA_8X_4v4 = 0x26, + AA_MODE_METHOD_VCAA_16X_4v12 = 0x27, + AA_MODE_METHOD_VCAA_16X_8v8 = 0x28, + AA_MODE_METHOD_MIXEDSAMPLE_32X = 0x29, + AA_MODE_METHOD_SUPERVCAA_64X_4v12 = 0x2a, + AA_MODE_METHOD_SUPERVCAA_64X_8v8 = 0x2b, + AA_MODE_METHOD_MIXEDSAMPLE_64X = 0x2c, + AA_MODE_METHOD_MIXEDSAMPLE_128X = 0x2d, + AA_MODE_METHOD_COUNT = 0x2e, + AA_MODE_METHOD_METHOD_MASK = 0x0000ffff, + AA_MODE_METHOD_METHOD_MAX = 0xf1c57815, + AA_MODE_METHOD_NUM_VALUES = 50, + AA_MODE_METHOD_DEFAULT = AA_MODE_METHOD_NONE +}; + +enum EValues_AA_MODE_REPLAY { + AA_MODE_REPLAY_SAMPLES_MASK = 0x00000070, + AA_MODE_REPLAY_SAMPLES_ONE = 0x00000000, + AA_MODE_REPLAY_SAMPLES_TWO = 0x00000010, + AA_MODE_REPLAY_SAMPLES_FOUR = 0x00000020, + AA_MODE_REPLAY_SAMPLES_EIGHT = 0x00000030, + AA_MODE_REPLAY_SAMPLES_MAX = 0x00000030, + AA_MODE_REPLAY_MODE_MASK = 0x0000000f, + AA_MODE_REPLAY_MODE_OFF = 0x00000000, + AA_MODE_REPLAY_MODE_ALPHA_TEST = 0x00000001, + AA_MODE_REPLAY_MODE_PIXEL_KILL = 0x00000002, + AA_MODE_REPLAY_MODE_DYN_BRANCH = 0x00000004, + AA_MODE_REPLAY_MODE_OPTIMAL = 0x00000004, + AA_MODE_REPLAY_MODE_ALL = 0x00000008, + AA_MODE_REPLAY_MODE_MAX = 0x0000000f, + AA_MODE_REPLAY_TRANSPARENCY = 0x00000023, + AA_MODE_REPLAY_DISALLOW_TRAA = 0x00000100, + AA_MODE_REPLAY_TRANSPARENCY_DEFAULT = 0x00000000, + AA_MODE_REPLAY_TRANSPARENCY_DEFAULT_TESLA = 0x00000000, + AA_MODE_REPLAY_TRANSPARENCY_DEFAULT_FERMI = 0x00000000, + AA_MODE_REPLAY_MASK = 0x0000017f, + AA_MODE_REPLAY_NUM_VALUES = 20, + AA_MODE_REPLAY_DEFAULT = 0x00000000 +}; + +enum EValues_AA_MODE_SELECTOR { + AA_MODE_SELECTOR_MASK = 0x00000003, + AA_MODE_SELECTOR_APP_CONTROL = 0x00000000, + AA_MODE_SELECTOR_OVERRIDE = 0x00000001, + AA_MODE_SELECTOR_ENHANCE = 0x00000002, + AA_MODE_SELECTOR_MAX = 0x00000002, + AA_MODE_SELECTOR_NUM_VALUES = 5, + AA_MODE_SELECTOR_DEFAULT = AA_MODE_SELECTOR_APP_CONTROL +}; + +enum EValues_AA_MODE_SELECTOR_SLIAA { + AA_MODE_SELECTOR_SLIAA_DISABLED = 0, + AA_MODE_SELECTOR_SLIAA_ENABLED = 1, + AA_MODE_SELECTOR_SLIAA_NUM_VALUES = 2, + AA_MODE_SELECTOR_SLIAA_DEFAULT = AA_MODE_SELECTOR_SLIAA_DISABLED +}; + +enum EValues_ANISO_MODE_LEVEL { + ANISO_MODE_LEVEL_MASK = 0x0000ffff, + ANISO_MODE_LEVEL_NONE_POINT = 0x00000000, + ANISO_MODE_LEVEL_NONE_LINEAR = 0x00000001, + ANISO_MODE_LEVEL_MAX = 0x00000010, + ANISO_MODE_LEVEL_DEFAULT = 0x00000001, + ANISO_MODE_LEVEL_NUM_VALUES = 5, +}; + +enum EValues_ANISO_MODE_SELECTOR { + ANISO_MODE_SELECTOR_MASK = 0x0000000f, + ANISO_MODE_SELECTOR_APP = 0x00000000, + ANISO_MODE_SELECTOR_USER = 0x00000001, + ANISO_MODE_SELECTOR_COND = 0x00000002, + ANISO_MODE_SELECTOR_MAX = 0x00000002, + ANISO_MODE_SELECTOR_DEFAULT = 0x00000000, + ANISO_MODE_SELECTOR_NUM_VALUES = 6, +}; + +enum EValues_ANSEL_ALLOW { + ANSEL_ALLOW_DISALLOWED = 0, + ANSEL_ALLOW_ALLOWED = 1, + ANSEL_ALLOW_NUM_VALUES = 2, + ANSEL_ALLOW_DEFAULT = ANSEL_ALLOW_ALLOWED +}; + +enum EValues_ANSEL_ALLOWLISTED { + ANSEL_ALLOWLISTED_DISALLOWED = 0, + ANSEL_ALLOWLISTED_ALLOWED = 1, + ANSEL_ALLOWLISTED_NUM_VALUES = 2, + ANSEL_ALLOWLISTED_DEFAULT = ANSEL_ALLOWLISTED_DISALLOWED +}; + +enum EValues_ANSEL_ENABLE { + ANSEL_ENABLE_OFF = 0, + ANSEL_ENABLE_ON = 1, + ANSEL_ENABLE_NUM_VALUES = 2, + ANSEL_ENABLE_DEFAULT = ANSEL_ENABLE_ON +}; + +enum EValues_APPLICATION_PROFILE_NOTIFICATION_TIMEOUT { + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_DISABLED = 0, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_NINE_SECONDS = 9, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_FIFTEEN_SECONDS = 15, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_THIRTY_SECONDS = 30, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_ONE_MINUTE = 60, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_TWO_MINUTES = 120, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_NUM_VALUES = 6, + APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_DEFAULT = APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_DISABLED +}; + +enum EValues_BATTERY_BOOST_APP_FPS { + BATTERY_BOOST_APP_FPS_MIN = 0x00000001, + BATTERY_BOOST_APP_FPS_MAX = 0x000003ff, + BATTERY_BOOST_APP_FPS_NO_OVERRIDE = 0x00000000, + BATTERY_BOOST_APP_FPS_NUM_VALUES = 3, + BATTERY_BOOST_APP_FPS_DEFAULT = BATTERY_BOOST_APP_FPS_NO_OVERRIDE +}; + +enum EValues_CPL_HIDDEN_PROFILE { + CPL_HIDDEN_PROFILE_DISABLED = 0, + CPL_HIDDEN_PROFILE_ENABLED = 1, + CPL_HIDDEN_PROFILE_NUM_VALUES = 2, + CPL_HIDDEN_PROFILE_DEFAULT = CPL_HIDDEN_PROFILE_DISABLED +}; + +#define CUDA_EXCLUDED_GPUS_NONE L"none" +#define CUDA_EXCLUDED_GPUS_NUM_VALUES 1 +#define CUDA_EXCLUDED_GPUS_DEFAULT CUDA_EXCLUDED_GPUS_NONE + +#define D3DOGL_GPU_MAX_POWER_DEFAULTPOWER L"0" +#define D3DOGL_GPU_MAX_POWER_NUM_VALUES 1 +#define D3DOGL_GPU_MAX_POWER_DEFAULT D3DOGL_GPU_MAX_POWER_DEFAULTPOWER + +enum EValues_EXPORT_PERF_COUNTERS { + EXPORT_PERF_COUNTERS_OFF = 0x00000000, + EXPORT_PERF_COUNTERS_ON = 0x00000001, + EXPORT_PERF_COUNTERS_NUM_VALUES = 2, + EXPORT_PERF_COUNTERS_DEFAULT = EXPORT_PERF_COUNTERS_OFF +}; + +enum EValues_EXTERNAL_QUIET_MODE { + EXTERNAL_QUIET_MODE_ON = 0x00000001, + EXTERNAL_QUIET_MODE_OFF = 0x00000000, + EXTERNAL_QUIET_MODE_NUM_VALUES = 2, + EXTERNAL_QUIET_MODE_DEFAULT = EXTERNAL_QUIET_MODE_OFF +}; + +enum EValues_FRL_FPS { + FRL_FPS_DISABLED = 0x00000000, + FRL_FPS_MIN = 0x00000000, + FRL_FPS_MAX = 0x000003ff, + FRL_FPS_NUM_VALUES = 3, + FRL_FPS_DEFAULT = FRL_FPS_DISABLED +}; + +enum EValues_FXAA_ALLOW { + FXAA_ALLOW_DISALLOWED = 0, + FXAA_ALLOW_ALLOWED = 1, + FXAA_ALLOW_NUM_VALUES = 2, + FXAA_ALLOW_DEFAULT = FXAA_ALLOW_ALLOWED +}; + +enum EValues_FXAA_ENABLE { + FXAA_ENABLE_OFF = 0, + FXAA_ENABLE_ON = 1, + FXAA_ENABLE_NUM_VALUES = 2, + FXAA_ENABLE_DEFAULT = FXAA_ENABLE_OFF +}; + +enum EValues_FXAA_INDICATOR_ENABLE { + FXAA_INDICATOR_ENABLE_OFF = 0, + FXAA_INDICATOR_ENABLE_ON = 1, + FXAA_INDICATOR_ENABLE_NUM_VALUES = 2, + FXAA_INDICATOR_ENABLE_DEFAULT = FXAA_INDICATOR_ENABLE_OFF +}; + +enum EValues_LATENCY_INDICATOR_AUTOALIGN { + LATENCY_INDICATOR_AUTOALIGN_DISABLED = 0x0, + LATENCY_INDICATOR_AUTOALIGN_ENABLED = 0x1, + LATENCY_INDICATOR_AUTOALIGN_NUM_VALUES = 2, + LATENCY_INDICATOR_AUTOALIGN_DEFAULT = LATENCY_INDICATOR_AUTOALIGN_ENABLED +}; + +enum EValues_MCSFRSHOWSPLIT { + MCSFRSHOWSPLIT_DISABLED = 0x34534064, + MCSFRSHOWSPLIT_ENABLED = 0x24545582, + MCSFRSHOWSPLIT_NUM_VALUES = 2, + MCSFRSHOWSPLIT_DEFAULT = MCSFRSHOWSPLIT_DISABLED +}; + +enum EValues_NGX_DLAA_OVERRIDE { + NGX_DLAA_OVERRIDE_DLAA_DEFAULT = 0, + NGX_DLAA_OVERRIDE_DLAA_ON = 1, + NGX_DLAA_OVERRIDE_NUM_VALUES = 2, + NGX_DLAA_OVERRIDE_DEFAULT = NGX_DLAA_OVERRIDE_DLAA_DEFAULT +}; + +enum EValues_NGX_DLSSG_MULTI_FRAME_COUNT { + NGX_DLSSG_MULTI_FRAME_COUNT_MIN = 1, + NGX_DLSSG_MULTI_FRAME_COUNT_MAX = 15, + NGX_DLSSG_MULTI_FRAME_COUNT_DEFAULT = 1, + NGX_DLSSG_MULTI_FRAME_COUNT_NUM_VALUES = 3, +}; + +enum EValues_NGX_DLSS_FG_OVERRIDE { + NGX_DLSS_FG_OVERRIDE_OFF = 0, + NGX_DLSS_FG_OVERRIDE_ON = 1, + NGX_DLSS_FG_OVERRIDE_NUM_VALUES = 2, + NGX_DLSS_FG_OVERRIDE_DEFAULT = NGX_DLSS_FG_OVERRIDE_OFF +}; + +enum EValues_NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1 { + NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_DEFAULT = 0, + NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_NUM_VALUES = 1, +}; + +enum EValues_NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2 { + NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_DEFAULT = 0, + NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_NUM_VALUES = 1, +}; + +enum EValues_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS { + NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NONE = 0x0000, + NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_PERF_TO_9X = 0x0001, + NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NUM_VALUES = 2, + NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_DEFAULT = NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NONE +}; + +enum EValues_NGX_DLSS_RR_MODE { + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_PERFORMANCE = 0, + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_BALANCED = 1, + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_QUALITY = 2, + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_SNIPPET_CONTROLLED = 3, + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_DLAA = 4, + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_ULTRA_PERFORMANCE = 5, + NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_CUSTOM = 6, + NGX_DLSS_RR_MODE_NUM_VALUES = 7, + NGX_DLSS_RR_MODE_DEFAULT = NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_SNIPPET_CONTROLLED +}; + +enum EValues_NGX_DLSS_RR_OVERRIDE { + NGX_DLSS_RR_OVERRIDE_OFF = 0, + NGX_DLSS_RR_OVERRIDE_ON = 1, + NGX_DLSS_RR_OVERRIDE_NUM_VALUES = 2, + NGX_DLSS_RR_OVERRIDE_DEFAULT = NGX_DLSS_RR_OVERRIDE_OFF +}; + +enum EValues_NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION { + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF = 0, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_A = 1, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_B = 2, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_C = 3, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_D = 4, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_E = 5, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_F = 6, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_G = 7, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_H = 8, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_I = 9, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_J = 10, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_K = 11, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_L = 12, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_M = 13, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_N = 14, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_O = 15, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Latest = 0x00ffffff, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_NUM_VALUES = 17, + NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_DEFAULT = NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF +}; + +enum EValues_NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1 { + NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_DEFAULT = 0, + NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_NUM_VALUES = 1, +}; + +enum EValues_NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2 { + NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_DEFAULT = 0, + NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_NUM_VALUES = 1, +}; + +enum EValues_NGX_DLSS_SR_MODE { + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_PERFORMANCE = 0, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_BALANCED = 1, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_QUALITY = 2, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_SNIPPET_CONTROLLED = 3, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_DLAA = 4, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_ULTRA_PERFORMANCE = 5, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_CUSTOM = 6, + NGX_DLSS_SR_MODE_NUM_VALUES = 7, + NGX_DLSS_SR_MODE_DEFAULT = NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_SNIPPET_CONTROLLED +}; + +enum EValues_NGX_DLSS_SR_OVERRIDE { + NGX_DLSS_SR_OVERRIDE_OFF = 0, + NGX_DLSS_SR_OVERRIDE_ON = 1, + NGX_DLSS_SR_OVERRIDE_NUM_VALUES = 2, + NGX_DLSS_SR_OVERRIDE_DEFAULT = NGX_DLSS_SR_OVERRIDE_OFF +}; + +enum EValues_NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION { + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF = 0, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_A = 1, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_B = 2, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_C = 3, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_D = 4, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_E = 5, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_F = 6, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_G = 7, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_H = 8, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_I = 9, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_J = 10, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_K = 11, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_L = 12, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_M = 13, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_N = 14, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_O = 15, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Latest = 0x00ffffff, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_NUM_VALUES = 17, + NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_DEFAULT = NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF +}; + +enum EValues_NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1 { + NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_DEFAULT = 0, + NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_NUM_VALUES = 1, +}; + +enum EValues_NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2 { + NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_DEFAULT = 0, + NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_NUM_VALUES = 1, +}; + +enum EValues_NV_QUALITY_UPSCALING { + NV_QUALITY_UPSCALING_OFF = 0, + NV_QUALITY_UPSCALING_ON = 1, + NV_QUALITY_UPSCALING_NUM_VALUES = 2, + NV_QUALITY_UPSCALING_DEFAULT = NV_QUALITY_UPSCALING_OFF +}; + +enum EValues_OPTIMUS_MAXAA { + OPTIMUS_MAXAA_MIN = 0, + OPTIMUS_MAXAA_MAX = 16, + OPTIMUS_MAXAA_NUM_VALUES = 2, + OPTIMUS_MAXAA_DEFAULT = 0 +}; + +enum EValues_PHYSXINDICATOR { + PHYSXINDICATOR_DISABLED = 0x34534064, + PHYSXINDICATOR_ENABLED = 0x24545582, + PHYSXINDICATOR_NUM_VALUES = 2, + PHYSXINDICATOR_DEFAULT = PHYSXINDICATOR_DISABLED +}; + +enum EValues_PREFERRED_PSTATE { + PREFERRED_PSTATE_ADAPTIVE = 0x00000000, + PREFERRED_PSTATE_PREFER_MAX = 0x00000001, + PREFERRED_PSTATE_DRIVER_CONTROLLED = 0x00000002, + PREFERRED_PSTATE_PREFER_CONSISTENT_PERFORMANCE = 0x00000003, + PREFERRED_PSTATE_PREFER_MIN = 0x00000004, + PREFERRED_PSTATE_OPTIMAL_POWER = 0x00000005, + PREFERRED_PSTATE_MIN = 0x00000000, + PREFERRED_PSTATE_MAX = 0x00000005, + PREFERRED_PSTATE_NUM_VALUES = 8, + PREFERRED_PSTATE_DEFAULT = PREFERRED_PSTATE_OPTIMAL_POWER +}; + +enum EValues_PREVENT_UI_AF_OVERRIDE { + PREVENT_UI_AF_OVERRIDE_OFF = 0, + PREVENT_UI_AF_OVERRIDE_ON = 1, + PREVENT_UI_AF_OVERRIDE_NUM_VALUES = 2, + PREVENT_UI_AF_OVERRIDE_DEFAULT = PREVENT_UI_AF_OVERRIDE_OFF +}; + +enum EValues_SHIM_MCCOMPAT { + SHIM_MCCOMPAT_INTEGRATED = 0x00000000U, + SHIM_MCCOMPAT_ENABLE = 0x00000001U, + SHIM_MCCOMPAT_USER_EDITABLE = 0x00000002U, + SHIM_MCCOMPAT_MASK = 0x00000003U, + SHIM_MCCOMPAT_VIDEO_MASK = 0x00000004U, + SHIM_MCCOMPAT_VARYING_BIT = 0x00000008U, + SHIM_MCCOMPAT_AUTO_SELECT = 0x00000010U, + SHIM_MCCOMPAT_OVERRIDE_BIT = 0x80000000U, + SHIM_MCCOMPAT_NUM_VALUES = 8, + SHIM_MCCOMPAT_DEFAULT = SHIM_MCCOMPAT_AUTO_SELECT +}; + +enum EValues_SHIM_RENDERING_MODE { + SHIM_RENDERING_MODE_INTEGRATED = 0x00000000U, + SHIM_RENDERING_MODE_ENABLE = 0x00000001U, + SHIM_RENDERING_MODE_USER_EDITABLE = 0x00000002U, + SHIM_RENDERING_MODE_MASK = 0x00000003U, + SHIM_RENDERING_MODE_VIDEO_MASK = 0x00000004U, + SHIM_RENDERING_MODE_VARYING_BIT = 0x00000008U, + SHIM_RENDERING_MODE_AUTO_SELECT = 0x00000010U, + SHIM_RENDERING_MODE_OVERRIDE_BIT = 0x80000000U, + SHIM_RENDERING_MODE_NUM_VALUES = 8, + SHIM_RENDERING_MODE_DEFAULT = SHIM_RENDERING_MODE_AUTO_SELECT +}; + +enum EValues_SHIM_RENDERING_OPTIONS { + SHIM_RENDERING_OPTIONS_DEFAULT_RENDERING_MODE = 0x00000000U, + SHIM_RENDERING_OPTIONS_DISABLE_ASYNC_PRESENT = 0x00000001U, + SHIM_RENDERING_OPTIONS_EHSHELL_DETECT = 0x00000002U, + SHIM_RENDERING_OPTIONS_FLASHPLAYER_HOST_DETECT = 0x00000004U, + SHIM_RENDERING_OPTIONS_VIDEO_DRM_APP_DETECT = 0x00000008U, + SHIM_RENDERING_OPTIONS_IGNORE_OVERRIDES = 0x00000010U, + SHIM_RENDERING_OPTIONS_RESERVED1 = 0x00000020U, + SHIM_RENDERING_OPTIONS_ENABLE_DWM_ASYNC_PRESENT = 0x00000040U, + SHIM_RENDERING_OPTIONS_RESERVED2 = 0x00000080U, + SHIM_RENDERING_OPTIONS_ALLOW_INHERITANCE = 0x00000100U, + SHIM_RENDERING_OPTIONS_DISABLE_WRAPPERS = 0x00000200U, + SHIM_RENDERING_OPTIONS_DISABLE_DXGI_WRAPPERS = 0x00000400U, + SHIM_RENDERING_OPTIONS_PRUNE_UNSUPPORTED_FORMATS = 0x00000800U, + SHIM_RENDERING_OPTIONS_ENABLE_ALPHA_FORMAT = 0x00001000U, + SHIM_RENDERING_OPTIONS_IGPU_TRANSCODING = 0x00002000U, + SHIM_RENDERING_OPTIONS_DISABLE_CUDA = 0x00004000U, + SHIM_RENDERING_OPTIONS_ALLOW_CP_CAPS_FOR_VIDEO = 0x00008000U, + SHIM_RENDERING_OPTIONS_IGPU_TRANSCODING_FWD_OPTIMUS = 0x00010000U, + SHIM_RENDERING_OPTIONS_DISABLE_DURING_SECURE_BOOT = 0x00020000U, + SHIM_RENDERING_OPTIONS_INVERT_FOR_QUADRO = 0x00040000U, + SHIM_RENDERING_OPTIONS_INVERT_FOR_MSHYBRID = 0x00080000U, + SHIM_RENDERING_OPTIONS_REGISTER_PROCESS_ENABLE_GOLD = 0x00100000U, + SHIM_RENDERING_OPTIONS_HANDLE_WINDOWED_MODE_PERF_OPT = 0x00200000U, + SHIM_RENDERING_OPTIONS_HANDLE_WIN7_ASYNC_RUNTIME_BUG = 0x00400000U, + SHIM_RENDERING_OPTIONS_EXPLICIT_ADAPTER_OPTED_BY_APP = 0x00800000U, + SHIM_RENDERING_OPTIONS_ALLOW_DYNAMIC_DISPLAY_MUX_SWITCH = 0x01000000U, + SHIM_RENDERING_OPTIONS_DISALLOW_DYNAMIC_DISPLAY_MUX_SWITCH = 0x02000000U, + SHIM_RENDERING_OPTIONS_DISABLE_TURING_POWER_POLICY = 0x04000000U, + SHIM_RENDERING_OPTIONS_ALLOW_DYNAMIC_DISPLAY_MUX_SWITCH_MDM = 0x08000000U, + SHIM_RENDERING_OPTIONS_DISALLOW_DYNAMIC_DISPLAY_MUX_SWITCH_MDM = 0x10000000U, + SHIM_RENDERING_OPTIONS_NUM_VALUES = 30, + SHIM_RENDERING_OPTIONS_DEFAULT = 0x00000000U +}; + +enum EValues_SLI_GPU_COUNT { + SLI_GPU_COUNT_AUTOSELECT = 0x00000000, + SLI_GPU_COUNT_ONE = 0x00000001, + SLI_GPU_COUNT_TWO = 0x00000002, + SLI_GPU_COUNT_THREE = 0x00000003, + SLI_GPU_COUNT_FOUR = 0x00000004, + SLI_GPU_COUNT_NUM_VALUES = 5, + SLI_GPU_COUNT_DEFAULT = SLI_GPU_COUNT_AUTOSELECT +}; + +enum EValues_SLI_PREDEFINED_GPU_COUNT { + SLI_PREDEFINED_GPU_COUNT_AUTOSELECT = 0x00000000, + SLI_PREDEFINED_GPU_COUNT_ONE = 0x00000001, + SLI_PREDEFINED_GPU_COUNT_TWO = 0x00000002, + SLI_PREDEFINED_GPU_COUNT_THREE = 0x00000003, + SLI_PREDEFINED_GPU_COUNT_FOUR = 0x00000004, + SLI_PREDEFINED_GPU_COUNT_NUM_VALUES = 5, + SLI_PREDEFINED_GPU_COUNT_DEFAULT = SLI_PREDEFINED_GPU_COUNT_AUTOSELECT +}; + +enum EValues_SLI_PREDEFINED_GPU_COUNT_DX10 { + SLI_PREDEFINED_GPU_COUNT_DX10_AUTOSELECT = 0x00000000, + SLI_PREDEFINED_GPU_COUNT_DX10_ONE = 0x00000001, + SLI_PREDEFINED_GPU_COUNT_DX10_TWO = 0x00000002, + SLI_PREDEFINED_GPU_COUNT_DX10_THREE = 0x00000003, + SLI_PREDEFINED_GPU_COUNT_DX10_FOUR = 0x00000004, + SLI_PREDEFINED_GPU_COUNT_DX10_NUM_VALUES = 5, + SLI_PREDEFINED_GPU_COUNT_DX10_DEFAULT = SLI_PREDEFINED_GPU_COUNT_DX10_AUTOSELECT +}; + +enum EValues_SLI_PREDEFINED_MODE { + SLI_PREDEFINED_MODE_AUTOSELECT = 0x00000000, + SLI_PREDEFINED_MODE_FORCE_SINGLE = 0x00000001, + SLI_PREDEFINED_MODE_FORCE_AFR = 0x00000002, + SLI_PREDEFINED_MODE_FORCE_AFR2 = 0x00000003, + SLI_PREDEFINED_MODE_FORCE_SFR = 0x00000004, + SLI_PREDEFINED_MODE_FORCE_AFR_OF_SFR__FALLBACK_3AFR = 0x00000005, + SLI_PREDEFINED_MODE_NUM_VALUES = 6, + SLI_PREDEFINED_MODE_DEFAULT = SLI_PREDEFINED_MODE_AUTOSELECT +}; + +enum EValues_SLI_PREDEFINED_MODE_DX10 { + SLI_PREDEFINED_MODE_DX10_AUTOSELECT = 0x00000000, + SLI_PREDEFINED_MODE_DX10_FORCE_SINGLE = 0x00000001, + SLI_PREDEFINED_MODE_DX10_FORCE_AFR = 0x00000002, + SLI_PREDEFINED_MODE_DX10_FORCE_AFR2 = 0x00000003, + SLI_PREDEFINED_MODE_DX10_FORCE_SFR = 0x00000004, + SLI_PREDEFINED_MODE_DX10_FORCE_AFR_OF_SFR__FALLBACK_3AFR = 0x00000005, + SLI_PREDEFINED_MODE_DX10_NUM_VALUES = 6, + SLI_PREDEFINED_MODE_DX10_DEFAULT = SLI_PREDEFINED_MODE_DX10_AUTOSELECT +}; + +enum EValues_SLI_RENDERING_MODE { + SLI_RENDERING_MODE_AUTOSELECT = 0x00000000, + SLI_RENDERING_MODE_FORCE_SINGLE = 0x00000001, + SLI_RENDERING_MODE_FORCE_AFR = 0x00000002, + SLI_RENDERING_MODE_FORCE_AFR2 = 0x00000003, + SLI_RENDERING_MODE_FORCE_SFR = 0x00000004, + SLI_RENDERING_MODE_FORCE_AFR_OF_SFR__FALLBACK_3AFR = 0x00000005, + SLI_RENDERING_MODE_NUM_VALUES = 6, + SLI_RENDERING_MODE_DEFAULT = SLI_RENDERING_MODE_AUTOSELECT +}; + +enum EValues_VRPRERENDERLIMIT { + VRPRERENDERLIMIT_MIN = 0x00, + VRPRERENDERLIMIT_MAX = 0xff, + VRPRERENDERLIMIT_APP_CONTROLLED = 0x00, + VRPRERENDERLIMIT_DEFAULT = 0x01, + VRPRERENDERLIMIT_NUM_VALUES = 4, +}; + +enum EValues_VRRFEATUREINDICATOR { + VRRFEATUREINDICATOR_DISABLED = 0x0, + VRRFEATUREINDICATOR_ENABLED = 0x1, + VRRFEATUREINDICATOR_NUM_VALUES = 2, + VRRFEATUREINDICATOR_DEFAULT = VRRFEATUREINDICATOR_ENABLED +}; + +enum EValues_VRROVERLAYINDICATOR { + VRROVERLAYINDICATOR_DISABLED = 0x0, + VRROVERLAYINDICATOR_ENABLED = 0x1, + VRROVERLAYINDICATOR_NUM_VALUES = 2, + VRROVERLAYINDICATOR_DEFAULT = VRROVERLAYINDICATOR_ENABLED +}; + +enum EValues_VRRREQUESTSTATE { + VRRREQUESTSTATE_DISABLED = 0x0, + VRRREQUESTSTATE_FULLSCREEN_ONLY = 0x1, + VRRREQUESTSTATE_FULLSCREEN_AND_WINDOWED = 0x2, + VRRREQUESTSTATE_NUM_VALUES = 3, + VRRREQUESTSTATE_DEFAULT = VRRREQUESTSTATE_FULLSCREEN_ONLY +}; + +enum EValues_VRR_APP_OVERRIDE { + VRR_APP_OVERRIDE_ALLOW = 0, + VRR_APP_OVERRIDE_FORCE_OFF = 1, + VRR_APP_OVERRIDE_DISALLOW = 2, + VRR_APP_OVERRIDE_ULMB = 3, + VRR_APP_OVERRIDE_FIXED_REFRESH = 4, + VRR_APP_OVERRIDE_NUM_VALUES = 5, + VRR_APP_OVERRIDE_DEFAULT = VRR_APP_OVERRIDE_ALLOW +}; + +enum EValues_VRR_APP_OVERRIDE_REQUEST_STATE { + VRR_APP_OVERRIDE_REQUEST_STATE_ALLOW = 0, + VRR_APP_OVERRIDE_REQUEST_STATE_FORCE_OFF = 1, + VRR_APP_OVERRIDE_REQUEST_STATE_DISALLOW = 2, + VRR_APP_OVERRIDE_REQUEST_STATE_ULMB = 3, + VRR_APP_OVERRIDE_REQUEST_STATE_FIXED_REFRESH = 4, + VRR_APP_OVERRIDE_REQUEST_STATE_NUM_VALUES = 5, + VRR_APP_OVERRIDE_REQUEST_STATE_DEFAULT = VRR_APP_OVERRIDE_REQUEST_STATE_ALLOW +}; + +enum EValues_VRR_MODE { + VRR_MODE_DISABLED = 0x0, + VRR_MODE_FULLSCREEN_ONLY = 0x1, + VRR_MODE_FULLSCREEN_AND_WINDOWED = 0x2, + VRR_MODE_NUM_VALUES = 3, + VRR_MODE_DEFAULT = VRR_MODE_FULLSCREEN_ONLY +}; + +enum EValues_VSYNCSMOOTHAFR { + VSYNCSMOOTHAFR_OFF = 0x00000000, + VSYNCSMOOTHAFR_ON = 0x00000001, + VSYNCSMOOTHAFR_NUM_VALUES = 2, + VSYNCSMOOTHAFR_DEFAULT = VSYNCSMOOTHAFR_OFF +}; + +enum EValues_VSYNCVRRCONTROL { + VSYNCVRRCONTROL_DISABLE = 0x00000000, + VSYNCVRRCONTROL_ENABLE = 0x00000001, + VSYNCVRRCONTROL_NOTSUPPORTED = 0x9f95128e, + VSYNCVRRCONTROL_NUM_VALUES = 3, + VSYNCVRRCONTROL_DEFAULT = VSYNCVRRCONTROL_ENABLE +}; + +enum EValues_VSYNC_BEHAVIOR_FLAGS { + VSYNC_BEHAVIOR_FLAGS_NONE = 0x00000000, + VSYNC_BEHAVIOR_FLAGS_DEFAULT = 0x00000000, + VSYNC_BEHAVIOR_FLAGS_IGNORE_FLIPINTERVAL_MULTIPLE = 0x00000001, + VSYNC_BEHAVIOR_FLAGS_NUM_VALUES = 3, +}; + +enum EValues_WKS_API_STEREO_EYES_EXCHANGE { + WKS_API_STEREO_EYES_EXCHANGE_OFF = 0, + WKS_API_STEREO_EYES_EXCHANGE_ON = 1, + WKS_API_STEREO_EYES_EXCHANGE_NUM_VALUES = 2, + WKS_API_STEREO_EYES_EXCHANGE_DEFAULT = WKS_API_STEREO_EYES_EXCHANGE_OFF +}; + +enum EValues_WKS_API_STEREO_MODE { + WKS_API_STEREO_MODE_SHUTTER_GLASSES = 0, + WKS_API_STEREO_MODE_VERTICAL_INTERLACED = 1, + WKS_API_STEREO_MODE_TWINVIEW = 2, + WKS_API_STEREO_MODE_NV17_SHUTTER_GLASSES_AUTO = 3, + WKS_API_STEREO_MODE_NV17_SHUTTER_GLASSES_DAC0 = 4, + WKS_API_STEREO_MODE_NV17_SHUTTER_GLASSES_DAC1 = 5, + WKS_API_STEREO_MODE_COLOR_LINE = 6, + WKS_API_STEREO_MODE_COLOR_INTERLEAVED = 7, + WKS_API_STEREO_MODE_ANAGLYPH = 8, + WKS_API_STEREO_MODE_HORIZONTAL_INTERLACED = 9, + WKS_API_STEREO_MODE_SIDE_FIELD = 10, + WKS_API_STEREO_MODE_SUB_FIELD = 11, + WKS_API_STEREO_MODE_CHECKERBOARD = 12, + WKS_API_STEREO_MODE_INVERSE_CHECKERBOARD = 13, + WKS_API_STEREO_MODE_TRIDELITY_SL = 14, + WKS_API_STEREO_MODE_TRIDELITY_MV = 15, + WKS_API_STEREO_MODE_SEEFRONT = 16, + WKS_API_STEREO_MODE_STEREO_MIRROR = 17, + WKS_API_STEREO_MODE_FRAME_SEQUENTIAL = 18, + WKS_API_STEREO_MODE_AUTODETECT_PASSIVE_MODE = 19, + WKS_API_STEREO_MODE_AEGIS_DT_FRAME_SEQUENTIAL = 20, + WKS_API_STEREO_MODE_OEM_EMITTER_FRAME_SEQUENTIAL = 21, + WKS_API_STEREO_MODE_DP_INBAND = 22, + WKS_API_STEREO_MODE_USE_HW_DEFAULT = 0xffffffff, + WKS_API_STEREO_MODE_DEFAULT_GL = 3, + WKS_API_STEREO_MODE_NUM_VALUES = 25, + WKS_API_STEREO_MODE_DEFAULT = WKS_API_STEREO_MODE_SHUTTER_GLASSES +}; + +enum EValues_WKS_STEREO_DONGLE_SUPPORT { + WKS_STEREO_DONGLE_SUPPORT_OFF = 0, + WKS_STEREO_DONGLE_SUPPORT_DAC = 1, + WKS_STEREO_DONGLE_SUPPORT_DLP = 2, + WKS_STEREO_DONGLE_SUPPORT_NUM_VALUES = 3, + WKS_STEREO_DONGLE_SUPPORT_DEFAULT = WKS_STEREO_DONGLE_SUPPORT_DAC +}; + +enum EValues_WKS_STEREO_SUPPORT { + WKS_STEREO_SUPPORT_OFF = 0, + WKS_STEREO_SUPPORT_ON = 1, + WKS_STEREO_SUPPORT_NUM_VALUES = 2, + WKS_STEREO_SUPPORT_DEFAULT = WKS_STEREO_SUPPORT_OFF +}; + +enum EValues_WKS_STEREO_SWAP_MODE { + WKS_STEREO_SWAP_MODE_APPLICATION_CONTROL = 0x0, + WKS_STEREO_SWAP_MODE_PER_EYE = 0x1, + WKS_STEREO_SWAP_MODE_PER_EYE_PAIR = 0x2, + WKS_STEREO_SWAP_MODE_LEGACY_BEHAVIOR = 0x3, + WKS_STEREO_SWAP_MODE_PER_EYE_FOR_SWAP_GROUP = 0x4, + WKS_STEREO_SWAP_MODE_NUM_VALUES = 5, + WKS_STEREO_SWAP_MODE_DEFAULT = WKS_STEREO_SWAP_MODE_APPLICATION_CONTROL +}; + +enum EValues_AO_MODE { + AO_MODE_OFF = 0, + AO_MODE_LOW = 1, + AO_MODE_MEDIUM = 2, + AO_MODE_HIGH = 3, + AO_MODE_NUM_VALUES = 4, + AO_MODE_DEFAULT = AO_MODE_OFF +}; + +enum EValues_AO_MODE_ACTIVE { + AO_MODE_ACTIVE_DISABLED = 0, + AO_MODE_ACTIVE_ENABLED = 1, + AO_MODE_ACTIVE_NUM_VALUES = 2, + AO_MODE_ACTIVE_DEFAULT = AO_MODE_ACTIVE_DISABLED +}; + +enum EValues_AUTO_LODBIASADJUST { + AUTO_LODBIASADJUST_OFF = 0x00000000, + AUTO_LODBIASADJUST_ON = 0x00000001, + AUTO_LODBIASADJUST_NUM_VALUES = 2, + AUTO_LODBIASADJUST_DEFAULT = AUTO_LODBIASADJUST_ON +}; + +enum EValues_EXPORT_PERF_COUNTERS_DX9_ONLY { + EXPORT_PERF_COUNTERS_DX9_ONLY_OFF = 0x00000000, + EXPORT_PERF_COUNTERS_DX9_ONLY_ON = 0x00000001, + EXPORT_PERF_COUNTERS_DX9_ONLY_NUM_VALUES = 2, + EXPORT_PERF_COUNTERS_DX9_ONLY_DEFAULT = EXPORT_PERF_COUNTERS_DX9_ONLY_OFF +}; + +enum EValues_LODBIASADJUST { + LODBIASADJUST_MIN = 0xffffff80, + LODBIASADJUST_MAX = 128, + LODBIASADJUST_NUM_VALUES = 2, + LODBIASADJUST_DEFAULT = 0 +}; + +enum EValues_MAXWELL_B_SAMPLE_INTERLEAVE { + MAXWELL_B_SAMPLE_INTERLEAVE_OFF = 0, + MAXWELL_B_SAMPLE_INTERLEAVE_ON = 1, + MAXWELL_B_SAMPLE_INTERLEAVE_NUM_VALUES = 2, + MAXWELL_B_SAMPLE_INTERLEAVE_DEFAULT = MAXWELL_B_SAMPLE_INTERLEAVE_OFF +}; + +enum EValues_PRERENDERLIMIT { + PRERENDERLIMIT_MIN = 0x00, + PRERENDERLIMIT_MAX = 0xff, + PRERENDERLIMIT_APP_CONTROLLED = 0x00, + PRERENDERLIMIT_NUM_VALUES = 3, + PRERENDERLIMIT_DEFAULT = PRERENDERLIMIT_APP_CONTROLLED +}; + +enum EValues_PS_SHADERDISKCACHE { + PS_SHADERDISKCACHE_OFF = 0x00000000, + PS_SHADERDISKCACHE_ON = 0x00000001, + PS_SHADERDISKCACHE_NUM_VALUES = 2, + PS_SHADERDISKCACHE_DEFAULT = PS_SHADERDISKCACHE_ON +}; + +enum EValues_PS_SHADERDISKCACHE_MAX_SIZE { + PS_SHADERDISKCACHE_MAX_SIZE_MIN = 0x0, + PS_SHADERDISKCACHE_MAX_SIZE_MAX = 0xffffffff, + PS_SHADERDISKCACHE_MAX_SIZE_NUM_VALUES = 2, + PS_SHADERDISKCACHE_MAX_SIZE_DEFAULT = 0x2000 +}; + +enum EValues_PS_TEXFILTER_ANISO_OPTS2 { + PS_TEXFILTER_ANISO_OPTS2_OFF = 0x00000000, + PS_TEXFILTER_ANISO_OPTS2_ON = 0x00000001, + PS_TEXFILTER_ANISO_OPTS2_NUM_VALUES = 2, + PS_TEXFILTER_ANISO_OPTS2_DEFAULT = PS_TEXFILTER_ANISO_OPTS2_OFF +}; + +enum EValues_PS_TEXFILTER_BILINEAR_IN_ANISO { + PS_TEXFILTER_BILINEAR_IN_ANISO_OFF = 0x00000000, + PS_TEXFILTER_BILINEAR_IN_ANISO_ON = 0x00000001, + PS_TEXFILTER_BILINEAR_IN_ANISO_NUM_VALUES = 2, + PS_TEXFILTER_BILINEAR_IN_ANISO_DEFAULT = PS_TEXFILTER_BILINEAR_IN_ANISO_OFF +}; + +enum EValues_PS_TEXFILTER_DISABLE_TRILIN_SLOPE { + PS_TEXFILTER_DISABLE_TRILIN_SLOPE_OFF = 0x00000000, + PS_TEXFILTER_DISABLE_TRILIN_SLOPE_ON = 0x00000001, + PS_TEXFILTER_DISABLE_TRILIN_SLOPE_NUM_VALUES = 2, + PS_TEXFILTER_DISABLE_TRILIN_SLOPE_DEFAULT = PS_TEXFILTER_DISABLE_TRILIN_SLOPE_OFF +}; + +enum EValues_PS_TEXFILTER_NO_NEG_LODBIAS { + PS_TEXFILTER_NO_NEG_LODBIAS_OFF = 0x00000000, + PS_TEXFILTER_NO_NEG_LODBIAS_ON = 0x00000001, + PS_TEXFILTER_NO_NEG_LODBIAS_NUM_VALUES = 2, + PS_TEXFILTER_NO_NEG_LODBIAS_DEFAULT = PS_TEXFILTER_NO_NEG_LODBIAS_OFF +}; + +enum EValues_QUALITY_ENHANCEMENTS { + QUALITY_ENHANCEMENTS_HIGHQUALITY = 0xfffffff6, + QUALITY_ENHANCEMENTS_QUALITY = 0x00000000, + QUALITY_ENHANCEMENTS_PERFORMANCE = 0x0000000a, + QUALITY_ENHANCEMENTS_HIGHPERFORMANCE = 0x00000014, + QUALITY_ENHANCEMENTS_NUM_VALUES = 4, + QUALITY_ENHANCEMENTS_DEFAULT = QUALITY_ENHANCEMENTS_QUALITY +}; + +enum EValues_QUALITY_ENHANCEMENT_SUBSTITUTION { + QUALITY_ENHANCEMENT_SUBSTITUTION_NO_SUBSTITUTION = 0x00000000, + QUALITY_ENHANCEMENT_SUBSTITUTION_HIGHQUALITY_BECOMES_QUALITY = 0x00000001, + QUALITY_ENHANCEMENT_SUBSTITUTION_NUM_VALUES = 2, + QUALITY_ENHANCEMENT_SUBSTITUTION_DEFAULT = QUALITY_ENHANCEMENT_SUBSTITUTION_NO_SUBSTITUTION +}; + +enum EValues_REFRESH_RATE_OVERRIDE { + REFRESH_RATE_OVERRIDE_APPLICATION_CONTROLLED = 0x00000000, + REFRESH_RATE_OVERRIDE_HIGHEST_AVAILABLE = 0x00000001, + REFRESH_RATE_OVERRIDE_LOW_LATENCY_RR_MASK = 0x00000FF0, + REFRESH_RATE_OVERRIDE_NUM_VALUES = 3, + REFRESH_RATE_OVERRIDE_DEFAULT = REFRESH_RATE_OVERRIDE_APPLICATION_CONTROLLED +}; + +enum EValues_SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE { + SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_OFF = 0x00000000, + SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_ON = 0x00000001, + SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_NUM_VALUES = 2, + SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_DEFAULT = SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_OFF +}; + +enum EValues_SET_VAB_DATA { + SET_VAB_DATA_ZERO = 0x00000000, + SET_VAB_DATA_UINT_ONE = 0x00000001, + SET_VAB_DATA_FLOAT_ONE = 0x3f800000, + SET_VAB_DATA_FLOAT_POS_INF = 0x7f800000, + SET_VAB_DATA_FLOAT_NAN = 0x7fc00000, + SET_VAB_DATA_USE_API_DEFAULTS = 0xffffffff, + SET_VAB_DATA_NUM_VALUES = 6, + SET_VAB_DATA_DEFAULT = SET_VAB_DATA_USE_API_DEFAULTS +}; + +enum EValues_VSYNCMODE { + VSYNCMODE_PASSIVE = 0x60925292, + VSYNCMODE_FORCEOFF = 0x08416747, + VSYNCMODE_FORCEON = 0x47814940, + VSYNCMODE_FLIPINTERVAL2 = 0x32610244, + VSYNCMODE_FLIPINTERVAL3 = 0x71271021, + VSYNCMODE_FLIPINTERVAL4 = 0x13245256, + VSYNCMODE_VIRTUAL = 0x18888888, + VSYNCMODE_NUM_VALUES = 7, + VSYNCMODE_DEFAULT = VSYNCMODE_PASSIVE +}; + +enum EValues_VSYNCTEARCONTROL { + VSYNCTEARCONTROL_DISABLE = 0x96861077, + VSYNCTEARCONTROL_ENABLE = 0x99941284, + VSYNCTEARCONTROL_NUM_VALUES = 2, + VSYNCTEARCONTROL_DEFAULT = VSYNCTEARCONTROL_DISABLE +}; + + + +typedef struct _SettingDWORDNameString { + NvU32 settingId; + const wchar_t * settingNameString; + NvU32 numSettingValues; + NvU32 *settingValues; + NvU32 defaultValue; +} SettingDWORDNameString; + +typedef struct _SettingWSTRINGNameString { + NvU32 settingId; + const wchar_t * settingNameString; + NvU32 numSettingValues; + const wchar_t **settingValues; + const wchar_t * defaultValue; +} SettingWSTRINGNameString; + + +#endif // _NVAPI_DRIVER_SETTINGS_H_ + diff --git a/external/nvapi/nvapi_interface.h b/external/nvapi/nvapi_interface.h new file mode 100644 index 00000000..800b9927 --- /dev/null +++ b/external/nvapi/nvapi_interface.h @@ -0,0 +1,546 @@ +/*********************************************************************************************************\ +|* *| +|* SPDX-FileCopyrightText: Copyright (c) 2019-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. *| +|* SPDX-License-Identifier: MIT *| +|* *| +|* Permission is hereby granted, free of charge, to any person obtaining a *| +|* copy of this software and associated documentation files (the "Software"), *| +|* to deal in the Software without restriction, including without limitation *| +|* the rights to use, copy, modify, merge, publish, distribute, sublicense, *| +|* and/or sell copies of the Software, and to permit persons to whom the *| +|* Software is furnished to do so, subject to the following conditions: *| +|* *| +|* The above copyright notice and this permission notice shall be included in *| +|* all copies or substantial portions of the Software. *| +|* *| +|* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *| +|* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *| +|* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *| +|* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *| +|* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *| +|* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *| +|* DEALINGS IN THE SOFTWARE. *| +|* *| +|* *| +\*********************************************************************************************************/ + +#ifndef _NVAPI_INTERFACE_H +#define _NVAPI_INTERFACE_H + +struct NVAPI_INTERFACE_TABLE { const char * func; unsigned int id; }; +struct NVAPI_INTERFACE_TABLE nvapi_interface_table[] = +{ + { "NvAPI_Initialize", 0x0150e828 }, + { "NvAPI_Unload", 0xd22bdd7e }, + { "NvAPI_GetErrorMessage", 0x6c2d048c }, + { "NvAPI_GetInterfaceVersionString", 0x01053fa5 }, + { "NvAPI_GPU_GetEDID", 0x37d32e69 }, + { "NvAPI_SetView", 0x0957d7b6 }, + { "NvAPI_SetViewEx", 0x06b89e68 }, + { "NvAPI_GetDisplayDriverVersion", 0xf951a4d1 }, + { "NvAPI_SYS_GetDriverAndBranchVersion", 0x2926aaad }, + { "NvAPI_GPU_GetMemoryInfo", 0x07f9b368 }, + { "NvAPI_GPU_GetMemoryInfoEx", 0xc0599498 }, + { "NvAPI_OGL_ExpertModeSet", 0x3805ef7a }, + { "NvAPI_OGL_ExpertModeGet", 0x22ed9516 }, + { "NvAPI_OGL_ExpertModeDefaultsSet", 0xb47a657e }, + { "NvAPI_OGL_ExpertModeDefaultsGet", 0xae921f12 }, + { "NvAPI_EnumPhysicalGPUs", 0xe5ac921f }, + { "NvAPI_EnumTCCPhysicalGPUs", 0xd9930b07 }, + { "NvAPI_EnumLogicalGPUs", 0x48b3ea59 }, + { "NvAPI_GetPhysicalGPUsFromDisplay", 0x34ef9506 }, + { "NvAPI_GetPhysicalGPUFromUnAttachedDisplay", 0x5018ed61 }, + { "NvAPI_GetLogicalGPUFromDisplay", 0xee1370cf }, + { "NvAPI_GetLogicalGPUFromPhysicalGPU", 0xadd604d1 }, + { "NvAPI_GetPhysicalGPUsFromLogicalGPU", 0xaea3fa32 }, + { "NvAPI_GetPhysicalGPUFromGPUID", 0x5380ad1a }, + { "NvAPI_GetGPUIDfromPhysicalGPU", 0x6533ea3e }, + { "NvAPI_GPU_GetShaderSubPipeCount", 0x0be17923 }, + { "NvAPI_GPU_GetGpuCoreCount", 0xc7026a87 }, + { "NvAPI_GPU_GetAllOutputs", 0x7d554f8e }, + { "NvAPI_GPU_GetConnectedOutputs", 0x1730bfc9 }, + { "NvAPI_GPU_GetConnectedSLIOutputs", 0x0680de09 }, + { "NvAPI_GPU_GetConnectedDisplayIds", 0x0078dba2 }, + { "NvAPI_GPU_GetAllDisplayIds", 0x785210a2 }, + { "NvAPI_GPU_GetConnectedOutputsWithLidState", 0xcf8caf39 }, + { "NvAPI_GPU_GetConnectedSLIOutputsWithLidState", 0x96043cc7 }, + { "NvAPI_GPU_GetSystemType", 0xbaaabfcc }, + { "NvAPI_GPU_GetActiveOutputs", 0xe3e89b6f }, + { "NvAPI_GPU_SetEDID", 0xe83d6456 }, + { "NvAPI_GPU_GetOutputType", 0x40a505e4 }, + { "NvAPI_GPU_ValidateOutputCombination", 0x34c9c2d4 }, + { "NvAPI_GPU_GetFullName", 0xceee8e9f }, + { "NvAPI_GPU_GetPCIIdentifiers", 0x2ddfb66e }, + { "NvAPI_GPU_GetGPUType", 0xc33baeb1 }, + { "NvAPI_GPU_GetBusType", 0x1bb18724 }, + { "NvAPI_GPU_GetBusId", 0x1be0b8e5 }, + { "NvAPI_GPU_GetBusSlotId", 0x2a0a350f }, + { "NvAPI_GPU_GetIRQ", 0xe4715417 }, + { "NvAPI_GPU_GetVbiosRevision", 0xacc3da0a }, + { "NvAPI_GPU_GetVbiosOEMRevision", 0x2d43fb31 }, + { "NvAPI_GPU_GetVbiosVersionString", 0xa561fd7d }, + { "NvAPI_GPU_GetAGPAperture", 0x6e042794 }, + { "NvAPI_GPU_GetCurrentAGPRate", 0xc74925a0 }, + { "NvAPI_GPU_GetCurrentPCIEDownstreamWidth", 0xd048c3b1 }, + { "NvAPI_GPU_GetPhysicalFrameBufferSize", 0x46fbeb03 }, + { "NvAPI_GPU_GetVirtualFrameBufferSize", 0x5a04b644 }, + { "NvAPI_GPU_GetQuadroStatus", 0xe332fa47 }, + { "NvAPI_GPU_GetBoardInfo", 0x22d54523 }, + { "NvAPI_GPU_GetRamBusWidth", 0x7975c581 }, + { "NvAPI_GPU_GetArchInfo", 0xd8265d24 }, + { "NvAPI_I2CRead", 0x2fde12c5 }, + { "NvAPI_I2CWrite", 0xe812eb07 }, + { "NvAPI_GPU_WorkstationFeatureSetup", 0x6c1f3fe4 }, + { "NvAPI_GPU_WorkstationFeatureQuery", 0x004537df }, + { "NvAPI_GPU_GetHDCPSupportStatus", 0xf089eef5 }, + { "NvAPI_GPU_CudaEnumComputeCapableGpus", 0x5786cc6e }, + { "NvAPI_GPU_GetTachReading", 0x5f608315 }, + { "NvAPI_GPU_GetECCStatusInfo", 0xca1ddaf3 }, + { "NvAPI_GPU_GetECCErrorInfo", 0xc71f85a6 }, + { "NvAPI_GPU_ResetECCErrorInfo", 0xc02eec20 }, + { "NvAPI_GPU_GetECCConfigurationInfo", 0x77a796f3 }, + { "NvAPI_GPU_SetECCConfiguration", 0x1cf639d9 }, + { "NvAPI_GPU_QueryWorkstationFeatureSupport", 0x80b1abb9 }, + { "NvAPI_GPU_SetScanoutIntensity", 0xa57457a4 }, + { "NvAPI_GPU_GetScanoutIntensityState", 0xe81ce836 }, + { "NvAPI_GPU_SetScanoutWarping", 0xb34bab4f }, + { "NvAPI_GPU_GetScanoutWarpingState", 0x6f5435af }, + { "NvAPI_GPU_SetScanoutCompositionParameter", 0xf898247d }, + { "NvAPI_GPU_GetScanoutCompositionParameter", 0x58fe51e6 }, + { "NvAPI_GPU_GetScanoutConfiguration", 0x6a9f5b63 }, + { "NvAPI_GPU_GetScanoutConfigurationEx", 0xe2e1e6f0 }, + { "NvAPI_GPU_GetAdapterIdFromPhysicalGpu", 0x0ff07fde }, + { "NvAPI_GPU_GetVirtualizationInfo", 0x44e022a9 }, + { "NvAPI_GPU_GetLogicalGpuInfo", 0x842b066e }, + { "NvAPI_GPU_GetLicensableFeatures", 0x3fc596aa }, + { "NvAPI_GPU_NVLINK_GetCaps", 0xbef1119d }, + { "NvAPI_GPU_NVLINK_GetStatus", 0xc72a38e3 }, + { "NvAPI_GPU_GetEncoderStatistics", 0xf0a9aeeb }, + { "NvAPI_GPU_GetEncoderSessionsInfo", 0xd8a72ce5 }, + { "NvAPI_GPU_GetGPUInfo", 0xafd1b02c }, + { "NvAPI_GPU_GetVRReadyData", 0x81d629c5 }, + { "NvAPI_GPU_GetGspFeatures", 0x581c4391 }, + { "NvAPI_GPU_GetPerfDecreaseInfo", 0x7f7f4600 }, + { "NvAPI_GPU_GetPstatesInfoEx", 0x843c0256 }, + { "NvAPI_GPU_GetPstates20", 0x6ff81213 }, + { "NvAPI_GPU_GetCurrentPstate", 0x927da4f6 }, + { "NvAPI_GPU_GetDynamicPstatesInfoEx", 0x60ded2ed }, + { "NvAPI_GPU_GetThermalSettings", 0xe3640a56 }, + { "NvAPI_GPU_GetAllClockFrequencies", 0xdcb616c3 }, + { "NvAPI_GPU_QueryIlluminationSupport", 0xa629da31 }, + { "NvAPI_GPU_GetIllumination", 0x9a1b9365 }, + { "NvAPI_GPU_SetIllumination", 0x0254a187 }, + { "NvAPI_GPU_ClientIllumDevicesGetInfo", 0xd4100e58 }, + { "NvAPI_GPU_ClientIllumDevicesGetControl", 0x73c01d58 }, + { "NvAPI_GPU_ClientIllumDevicesSetControl", 0x57024c62 }, + { "NvAPI_GPU_ClientIllumZonesGetInfo", 0x4b81241b }, + { "NvAPI_GPU_ClientIllumZonesGetControl", 0x3dbf5764 }, + { "NvAPI_GPU_ClientIllumZonesSetControl", 0x197d065e }, + { "NvAPI_Event_RegisterCallback", 0xe6dbea69 }, + { "NvAPI_Event_UnregisterCallback", 0xde1f9b45 }, + { "NvAPI_EnumNvidiaDisplayHandle", 0x9abdd40d }, + { "NvAPI_EnumNvidiaUnAttachedDisplayHandle", 0x20de9260 }, + { "NvAPI_CreateDisplayFromUnAttachedDisplay", 0x63f9799e }, + { "NvAPI_GetAssociatedNvidiaDisplayHandle", 0x35c29134 }, + { "NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle", 0xa70503b2 }, + { "NvAPI_GetAssociatedNvidiaDisplayName", 0x22a78b05 }, + { "NvAPI_GetUnAttachedAssociatedDisplayName", 0x4888d790 }, + { "NvAPI_EnableHWCursor", 0x2863148d }, + { "NvAPI_DisableHWCursor", 0xab163097 }, + { "NvAPI_GetVBlankCounter", 0x67b5db55 }, + { "NvAPI_SetRefreshRateOverride", 0x3092ac32 }, + { "NvAPI_GetAssociatedDisplayOutputId", 0xd995937e }, + { "NvAPI_GetDisplayPortInfo", 0xc64ff367 }, + { "NvAPI_SetDisplayPort", 0xfa13e65a }, + { "NvAPI_GetHDMISupportInfo", 0x6ae16ec3 }, + { "NvAPI_Disp_InfoFrameControl", 0x6067af3f }, + { "NvAPI_Disp_ColorControl", 0x92f9d80d }, + { "NvAPI_Disp_GetHdrCapabilities", 0x84f2a8df }, + { "NvAPI_Disp_HdrColorControl", 0x351da224 }, + { "NvAPI_Disp_SetSourceColorSpace", 0x473b6caf }, + { "NvAPI_Disp_GetSourceColorSpace", 0xceedc85b }, + { "NvAPI_Disp_SetSourceHdrMetadata", 0x905eb63b }, + { "NvAPI_Disp_GetSourceHdrMetadata", 0x0d3f52da }, + { "NvAPI_Disp_SetOutputMode", 0x98e7661a }, + { "NvAPI_Disp_GetOutputMode", 0x81fed88d }, + { "NvAPI_Disp_SetHdrToneMapping", 0xdd6da362 }, + { "NvAPI_Disp_GetHdrToneMapping", 0xfbd36e71 }, + { "NvAPI_DISP_GetTiming", 0x175167e9 }, + { "NvAPI_DISP_GetMonitorCapabilities", 0x3b05c7e1 }, + { "NvAPI_DISP_GetMonitorColorCapabilities", 0x6ae4cfb5 }, + { "NvAPI_DISP_EnumCustomDisplay", 0xa2072d59 }, + { "NvAPI_DISP_TryCustomDisplay", 0x1f7db630 }, + { "NvAPI_DISP_DeleteCustomDisplay", 0x552e5b9b }, + { "NvAPI_DISP_SaveCustomDisplay", 0x49882876 }, + { "NvAPI_DISP_RevertCustomDisplayTrial", 0xcbbd40f0 }, + { "NvAPI_GetView", 0xd6b99d89 }, + { "NvAPI_GetViewEx", 0xdbbc0af4 }, + { "NvAPI_GetSupportedViews", 0x66fb7fc0 }, + { "NvAPI_DISP_GetDisplayIdByDisplayName", 0xae457190 }, + { "NvAPI_DISP_GetGDIPrimaryDisplayId", 0x1e9d8a31 }, + { "NvAPI_DISP_GetDisplayConfig", 0x11abccf8 }, + { "NvAPI_DISP_SetDisplayConfig", 0x5d8cf8de }, + { "NvAPI_DISP_GetEdidData", 0x436ced76 }, + { "NvAPI_DISP_GetAdaptiveSyncData", 0xb73d1ee9 }, + { "NvAPI_DISP_SetAdaptiveSyncData", 0x3eebba1d }, + { "NvAPI_DISP_GetVirtualRefreshRateData", 0x8c00429a }, + { "NvAPI_DISP_SetVirtualRefreshRateData", 0x5abbe6a3 }, + { "NvAPI_DISP_SetPreferredStereoDisplay", 0xc9d0e25f }, + { "NvAPI_DISP_GetPreferredStereoDisplay", 0x1f6b4666 }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplays", 0xdbdf0cb2 }, + { "NvAPI_DISP_AcquireDedicatedDisplay", 0x47c917ba }, + { "NvAPI_DISP_ReleaseDedicatedDisplay", 0x1247825f }, + { "NvAPI_DISP_GetNvManagedDedicatedDisplayMetadata", 0xd645d80c }, + { "NvAPI_DISP_SetNvManagedDedicatedDisplayMetadata", 0x3d8b129a }, + { "NvAPI_Disp_GetDisplayIdInfo", 0xbae8aa5e }, + { "NvAPI_Disp_GetDisplayIdsFromTarget", 0xe7e5f89e }, + { "NvAPI_Disp_GetVRRInfo", 0xdf8fda57 }, + { "NvAPI_Mosaic_GetSupportedTopoInfo", 0xfdb63c81 }, + { "NvAPI_Mosaic_GetTopoGroup", 0xcb89381d }, + { "NvAPI_Mosaic_GetOverlapLimits", 0x989685f0 }, + { "NvAPI_Mosaic_SetCurrentTopo", 0x9b542831 }, + { "NvAPI_Mosaic_GetCurrentTopo", 0xec32944e }, + { "NvAPI_Mosaic_EnableCurrentTopo", 0x5f1aa66c }, + { "NvAPI_Mosaic_GetDisplayViewportsByResolution", 0xdc6dc8d3 }, + { "NvAPI_Mosaic_SetDisplayGrids", 0x4d959a89 }, + { "NvAPI_Mosaic_ValidateDisplayGrids", 0xcf43903d }, + { "NvAPI_Mosaic_EnumDisplayModes", 0x78db97d7 }, + { "NvAPI_Mosaic_EnumDisplayGrids", 0xdf2887af }, + { "NvAPI_GetSupportedMosaicTopologies", 0x410b5c25 }, + { "NvAPI_GetCurrentMosaicTopology", 0xf60852bd }, + { "NvAPI_SetCurrentMosaicTopology", 0xd54b8989 }, + { "NvAPI_EnableCurrentMosaicTopology", 0x74073cc9 }, + { "NvAPI_GSync_EnumSyncDevices", 0xd9639601 }, + { "NvAPI_GSync_QueryCapabilities", 0x44a3f1d1 }, + { "NvAPI_GSync_GetTopology", 0x4562bc38 }, + { "NvAPI_GSync_SetSyncStateSettings", 0x60acdfdd }, + { "NvAPI_GSync_GetControlParameters", 0x16de1c6a }, + { "NvAPI_GSync_SetControlParameters", 0x8bbff88b }, + { "NvAPI_GSync_AdjustSyncDelay", 0x2d11ff51 }, + { "NvAPI_GSync_GetSyncStatus", 0xf1f5b434 }, + { "NvAPI_GSync_GetStatusParameters", 0x70d404ec }, + { "NvAPI_D3D_GetCurrentSLIState", 0x4b708b54 }, + { "NvAPI_D3D9_RegisterResource", 0xa064bdfc }, + { "NvAPI_D3D9_UnregisterResource", 0xbb2b17aa }, + { "NvAPI_D3D9_AliasSurfaceAsTexture", 0xe5ceae41 }, + { "NvAPI_D3D9_StretchRectEx", 0x22de03aa }, + { "NvAPI_D3D9_ClearRT", 0x332d3942 }, + { "NvAPI_D3D_GetObjectHandleForResource", 0xfceac864 }, + { "NvAPI_D3D_SetResourceHint", 0x6c0ed98c }, + { "NvAPI_D3D_BeginResourceRendering", 0x91123d6a }, + { "NvAPI_D3D_EndResourceRendering", 0x37e7191c }, + { "NvAPI_D3D9_GetSurfaceHandle", 0x0f2dd3f2 }, + { "NvAPI_D3D9_VideoSetStereoInfo", 0xb852f4db }, + { "NvAPI_D3D10_SetDepthBoundsTest", 0x4eadf5d2 }, + { "NvAPI_D3D11_CreateDevice", 0x6a16d3a0 }, + { "NvAPI_D3D11_CreateDeviceAndSwapChain", 0xbb939ee5 }, + { "NvAPI_D3D11_SetDepthBoundsTest", 0x7aaf7a04 }, + { "NvAPI_D3D11_IsNvShaderExtnOpCodeSupported", 0x5f68da40 }, + { "NvAPI_D3D11_SetNvShaderExtnSlot", 0x8e90bb9f }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpace", 0xac2dfeb5 }, + { "NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread", 0x43d867c0 }, + { "NvAPI_D3D11_SetNvShaderExtnSlotLocalThread", 0x0e6482a0 }, + { "NvAPI_D3D11_BeginUAVOverlapEx", 0xba08208a }, + { "NvAPI_D3D11_BeginUAVOverlap", 0x65b93ca8 }, + { "NvAPI_D3D11_EndUAVOverlap", 0x2216a357 }, + { "NvAPI_D3D11_GetResourceHandle", 0x09d52986 }, + { "NvAPI_D3D_SetFPSIndicatorState", 0xa776e8db }, + { "NvAPI_D3D9_Present", 0x05650beb }, + { "NvAPI_D3D9_QueryFrameCount", 0x9083e53a }, + { "NvAPI_D3D9_ResetFrameCount", 0xfa6a0675 }, + { "NvAPI_D3D9_QueryMaxSwapGroup", 0x5995410d }, + { "NvAPI_D3D9_QuerySwapGroup", 0xeba4d232 }, + { "NvAPI_D3D9_JoinSwapGroup", 0x7d44bb54 }, + { "NvAPI_D3D9_BindSwapBarrier", 0x9c39c246 }, + { "NvAPI_D3D_SetVerticalSyncMode", 0x5526cfd1 }, + { "NvAPI_D3D1x_Present", 0x03b845a1 }, + { "NvAPI_D3D1x_QueryFrameCount", 0x9152e055 }, + { "NvAPI_D3D1x_ResetFrameCount", 0xfbbb031a }, + { "NvAPI_D3D1x_QueryMaxSwapGroup", 0x9bb9d68f }, + { "NvAPI_D3D1x_QuerySwapGroup", 0x407f67aa }, + { "NvAPI_D3D1x_JoinSwapGroup", 0x14610cd7 }, + { "NvAPI_D3D1x_BindSwapBarrier", 0x9de8c729 }, + { "NvAPI_D3D12_QueryPresentBarrierSupport", 0xa15faef7 }, + { "NvAPI_D3D12_CreatePresentBarrierClient", 0x4d815de9 }, + { "NvAPI_D3D12_RegisterPresentBarrierResources", 0xd53c9ef0 }, + { "NvAPI_DestroyPresentBarrierClient", 0x3c5c351b }, + { "NvAPI_JoinPresentBarrier", 0x17f6bf82 }, + { "NvAPI_LeavePresentBarrier", 0xc3ec5a7f }, + { "NvAPI_QueryPresentBarrierFrameStatistics", 0x61b844a1 }, + { "NvAPI_D3D12_CreateDDisplayPresentBarrierClient", 0xb5a21987 }, + { "NvAPI_D3D11_CreateRasterizerState", 0xdb8d28af }, + { "NvAPI_D3D_ConfigureAnsel", 0x341c6c7f }, + { "NvAPI_D3D11_CreateTiledTexture2DArray", 0x7886981a }, + { "NvAPI_D3D11_CheckFeatureSupport", 0x106a487e }, + { "NvAPI_D3D11_CreateImplicitMSAATexture2D", 0xb8f79632 }, + { "NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D", 0x24c6a07b }, + { "NvAPI_D3D11_ResolveSubresourceRegion", 0xe6bfedd6 }, + { "NvAPI_D3D12_ResolveSubresourceRegion", 0xc24a15bf }, + { "NvAPI_D3D11_TiledTexture2DArrayGetDesc", 0xf1a2b9d5 }, + { "NvAPI_D3D11_UpdateTileMappings", 0x9a06ea07 }, + { "NvAPI_D3D11_CopyTileMappings", 0xc09ee6bc }, + { "NvAPI_D3D11_TiledResourceBarrier", 0xd6839099 }, + { "NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA", 0xf1c54fc9 }, + { "NvAPI_D3D11_CreateGeometryShaderEx_2", 0x99ed5c1c }, + { "NvAPI_D3D11_CreateVertexShaderEx", 0x0beaa0b2 }, + { "NvAPI_D3D11_CreateHullShaderEx", 0xb53cab00 }, + { "NvAPI_D3D11_CreateDomainShaderEx", 0xa0d7180d }, + { "NvAPI_D3D11_CreatePixelShaderEx_2", 0x4162822b }, + { "NvAPI_D3D11_CreateFastGeometryShaderExplicit", 0x71ab7c9c }, + { "NvAPI_D3D11_CreateFastGeometryShader", 0x525d43be }, + { "NvAPI_D3D11_DecompressView", 0x3a94e822 }, + { "NvAPI_D3D12_CreateGraphicsPipelineState", 0x2fc28856 }, + { "NvAPI_D3D12_CreateComputePipelineState", 0x2762deac }, + { "NvAPI_D3D12_SetDepthBoundsTestValues", 0xb9333fe9 }, + { "NvAPI_D3D12_CreateReservedResource", 0x2c85f101 }, + { "NvAPI_D3D12_CreateHeap", 0x5cb397cf }, + { "NvAPI_D3D12_CreateHeap2", 0x924be9d6 }, + { "NvAPI_D3D12_QueryCpuVisibleVidmem", 0x26322bc3 }, + { "NvAPI_D3D12_ReservedResourceGetDesc", 0x9aa2aabb }, + { "NvAPI_D3D12_UpdateTileMappings", 0xc6017a7d }, + { "NvAPI_D3D12_CopyTileMappings", 0x47f78194 }, + { "NvAPI_D3D12_ResourceAliasingBarrier", 0xb942bab7 }, + { "NvAPI_D3D12_CaptureUAVInfo", 0x6e5ea9db }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddressEx", 0xaf6d14da }, + { "NvAPI_D3D11_EnumerateMetaCommands", 0xc7453ba8 }, + { "NvAPI_D3D11_CreateMetaCommand", 0xf505fba0 }, + { "NvAPI_D3D11_InitializeMetaCommand", 0xaec629e9 }, + { "NvAPI_D3D11_ExecuteMetaCommand", 0x82236c47 }, + { "NvAPI_D3D12_EnumerateMetaCommands", 0xcd9141d8 }, + { "NvAPI_D3D12_CreateMetaCommand", 0xeb29634b }, + { "NvAPI_D3D12_InitializeMetaCommand", 0xa4125399 }, + { "NvAPI_D3D12_ExecuteMetaCommand", 0xde24fc3d }, + { "NvAPI_D3D12_CreateCommittedResource", 0x027e98ae }, + { "NvAPI_D3D12_GetCopyableFootprints", 0xf6305eb5 }, + { "NvAPI_D3D12_CopyTextureRegion", 0x82b91b25 }, + { "NvAPI_D3D12_IsNvShaderExtnOpCodeSupported", 0x3dfacec8 }, + { "NvAPI_D3D12_GetOptimalThreadCountForMesh", 0xb43995cb }, + { "NvAPI_D3D_IsGSyncCapable", 0x9c1eed78 }, + { "NvAPI_D3D_IsGSyncActive", 0xe942b0ff }, + { "NvAPI_D3D1x_DisableShaderDiskCache", 0xd0cbca7d }, + { "NvAPI_D3D11_MultiGPU_GetCaps", 0xd2d25687 }, + { "NvAPI_D3D11_MultiGPU_Init", 0x017be49e }, + { "NvAPI_D3D11_CreateMultiGPUDevice", 0xbdb20007 }, + { "NvAPI_D3D_QuerySinglePassStereoSupport", 0x6f5f0a6d }, + { "NvAPI_D3D_SetSinglePassStereoMode", 0xa39e6e6e }, + { "NvAPI_D3D12_QuerySinglePassStereoSupport", 0x3b03791b }, + { "NvAPI_D3D12_SetSinglePassStereoMode", 0x83556d87 }, + { "NvAPI_D3D_QueryMultiViewSupport", 0xb6e0a41c }, + { "NvAPI_D3D_SetMultiViewMode", 0x8285c8da }, + { "NvAPI_D3D_QueryModifiedWSupport", 0xcbf9f4f5 }, + { "NvAPI_D3D_SetModifiedWMode", 0x06ea4bf4 }, + { "NvAPI_D3D12_QueryModifiedWSupport", 0x51235248 }, + { "NvAPI_D3D12_SetModifiedWMode", 0xe1fdaba7 }, + { "NvAPI_D3D_CreateLateLatchObject", 0x2db27d09 }, + { "NvAPI_D3D_QueryLateLatchSupport", 0x8ceca0ec }, + { "NvAPI_D3D_RegisterDevice", 0x8c02c4d0 }, + { "NvAPI_D3D11_MultiDrawInstancedIndirect", 0xd4e26bbf }, + { "NvAPI_D3D11_MultiDrawIndexedInstancedIndirect", 0x59e890f9 }, + { "NvAPI_D3D_ImplicitSLIControl", 0x2aede111 }, + { "NvAPI_D3D12_GetNeedsAppFPBlendClamping", 0x6ef4d2d1 }, + { "NvAPI_D3D12_UseDriverHeapPriorities", 0xf0d978a8 }, + { "NvAPI_D3D12_Mosaic_GetCompanionAllocations", 0xa46022c7 }, + { "NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions", 0xb092b818 }, + { "NvAPI_D3D1x_GetGraphicsCapabilities", 0x52b1499a }, + { "NvAPI_D3D12_GetGraphicsCapabilities", 0x01e87354 }, + { "NvAPI_D3D11_RSSetExclusiveScissorRects", 0xae4d73ef }, + { "NvAPI_D3D11_RSSetViewportsPixelShadingRates", 0x34f7938f }, + { "NvAPI_D3D11_CreateShadingRateResourceView", 0x99ca2dff }, + { "NvAPI_D3D11_RSSetShadingRateResourceView", 0x1b0c2f83 }, + { "NvAPI_D3D11_RSGetPixelShadingRateSampleOrder", 0x092442a1 }, + { "NvAPI_D3D11_RSSetPixelShadingRateSampleOrder", 0xa942373a }, + { "NvAPI_D3D_InitializeVRSHelper", 0x4780d70b }, + { "NvAPI_D3D_InitializeNvGazeHandler", 0x5b3b7479 }, + { "NvAPI_D3D_InitializeSMPAssist", 0x42763d0c }, + { "NvAPI_D3D_QuerySMPAssistSupport", 0xc57921de }, + { "NvAPI_D3D_GetSleepStatus", 0xaef96ca1 }, + { "NvAPI_D3D_SetSleepMode", 0xac1ca9e0 }, + { "NvAPI_D3D_Sleep", 0x852cd1d2 }, + { "NvAPI_D3D_SetReflexSync", 0xb9f6faff }, + { "NvAPI_D3D_GetLatency", 0x1a587f9c }, + { "NvAPI_D3D_SetLatencyMarker", 0xd9984c05 }, + { "NvAPI_D3D12_SetAsyncFrameMarker", 0x13c98f73 }, + { "NvAPI_D3D11_SetAsyncFrameMarker", 0x59c2c510 }, + { "NvAPI_D3D12_NotifyOutOfBandCommandQueue", 0x03d6e8cb }, + { "NvAPI_D3D12_SetCreateCommandQueueLowLatencyHint", 0x548c224f }, + { "NvAPI_D3D12_CreateCubinComputeShaderExV2", 0x299f5fdc }, + { "NvAPI_D3D12_CreateCubinComputeShader", 0x2a2c79e8 }, + { "NvAPI_D3D12_CreateCubinComputeShaderEx", 0x3151211b }, + { "NvAPI_D3D12_CreateCubinComputeShaderWithName", 0x1dc7261f }, + { "NvAPI_D3D12_LaunchCubinShader", 0x5c52bb86 }, + { "NvAPI_D3D12_DestroyCubinComputeShader", 0x7fb785ba }, + { "NvAPI_D3D12_GetCudaMergedTextureSamplerObject", 0x329fe6e0 }, + { "NvAPI_D3D12_GetCudaIndependentDescriptorObject", 0x0ddac234 }, + { "NvAPI_D3D12_GetCudaTextureObject", 0x80403fc9 }, + { "NvAPI_D3D12_GetCudaSurfaceObject", 0x48f5b2ee }, + { "NvAPI_D3D12_IsFatbinPTXSupported", 0x70c07832 }, + { "NvAPI_D3D12_CreateCuModule", 0xad1a677d }, + { "NvAPI_D3D12_EnumFunctionsInModule", 0x7ab88d88 }, + { "NvAPI_D3D12_CreateCuFunction", 0xe2436e22 }, + { "NvAPI_D3D12_LaunchCuKernelChain", 0x24973538 }, + { "NvAPI_D3D12_LaunchCuKernelChainEx", 0x846a9bf0 }, + { "NvAPI_D3D12_DestroyCuModule", 0x41c65285 }, + { "NvAPI_D3D12_DestroyCuFunction", 0xdf295ea6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderExV2", 0xf2c71d48 }, + { "NvAPI_D3D11_CreateCubinComputeShader", 0x0ed98181 }, + { "NvAPI_D3D11_CreateCubinComputeShaderEx", 0x32c2a0f6 }, + { "NvAPI_D3D11_CreateCubinComputeShaderWithName", 0xb672be19 }, + { "NvAPI_D3D11_LaunchCubinShader", 0x427e236d }, + { "NvAPI_D3D11_DestroyCubinComputeShader", 0x01682c86 }, + { "NvAPI_D3D11_IsFatbinPTXSupported", 0x6086bd93 }, + { "NvAPI_D3D11_GetCudaIndependentViewObject", 0x34d2afa8 }, + { "NvAPI_D3D11_GetCudaMergedTextureSamplerObject", 0x5d637d8f }, + { "NvAPI_D3D11_CreateUnorderedAccessView", 0x74a497a1 }, + { "NvAPI_D3D11_CreateShaderResourceView", 0x65cb431e }, + { "NvAPI_D3D11_CreateSamplerState", 0x89eca416 }, + { "NvAPI_D3D11_GetCudaTextureObject", 0x9006fa68 }, + { "NvAPI_D3D11_GetResourceGPUVirtualAddress", 0x1819b423 }, + { "NvAPI_D3D12_GetRaytracingCaps", 0x85a6c2a0 }, + { "NvAPI_D3D12_EnableRaytracingValidation", 0x1de5991b }, + { "NvAPI_D3D12_RegisterRaytracingValidationMessageCallback", 0x8554eb38 }, + { "NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback", 0x26975da6 }, + { "NvAPI_D3D12_FlushRaytracingValidationMessages", 0xb8fb1fcb }, + { "NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo", 0xfa99b6de }, + { "NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo", 0x4726d180 }, + { "NvAPI_D3D12_SetCreatePipelineStateOptions", 0x5c607a27 }, + { "NvAPI_D3D12_CheckDriverMatchingIdentifierEx", 0xafb237d4 }, + { "NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx", 0x8d025b77 }, + { "NvAPI_D3D12_BuildRaytracingOpacityMicromapArray", 0x814f8d11 }, + { "NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray", 0x0425c538 }, + { "NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray", 0x066f569d }, + { "NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray", 0x1c142308 }, + { "NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo", 0x68b9a790 }, + { "NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo", 0x1d9a39b6 }, + { "NvAPI_D3D12_BuildRaytracingAccelerationStructureEx", 0xe24ead45 }, + { "NvAPI_D3D12_QueryWorkstationFeatureProperties", 0xa92ea23a }, + { "NvAPI_D3D12_CreateCommittedRDMABuffer", 0xe78dcb44 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrix", 0x0f252cb3 }, + { "NvAPI_D3D12_ConvertCooperativeVectorMatrixMultiple", 0x96ba5235 }, + { "NvAPI_D3D12_GetPhysicalDeviceCooperativeVectorProperties", 0x8f182aec }, + { "NvAPI_D3D12_GetRaytracingMultiIndirectClusterOperationRequirementsInfo", 0x5c9163f4 }, + { "NvAPI_D3D12_RaytracingExecuteMultiIndirectClusterOperation", 0x67c798af }, + { "NvAPI_D3D12_GetRaytracingPartitionedTlasIndirectPrebuildInfo", 0xcdfdc5f2 }, + { "NvAPI_D3D12_BuildRaytracingPartitionedTlasIndirect", 0x7cfc6fc3 }, + { "NvAPI_NGX_GetNGXOverrideState", 0x3fd96fba }, + { "NvAPI_NGX_SetNGXOverrideState", 0xb60fcb4e }, + { "NvAPI_DirectD3D12GraphicsCommandList_Create", 0x74a4e712 }, + { "NvAPI_DirectD3D12GraphicsCommandList_Release", 0x99da3dde }, + { "NvAPI_DirectD3D12GraphicsCommandList_Reset", 0x999c26d8 }, + { "NvAPI_VIO_GetCapabilities", 0x1dc91303 }, + { "NvAPI_VIO_Open", 0x44ee4841 }, + { "NvAPI_VIO_Close", 0xd01bd237 }, + { "NvAPI_VIO_Status", 0x0e6ce4f1 }, + { "NvAPI_VIO_SyncFormatDetect", 0x118d48a3 }, + { "NvAPI_VIO_GetConfig", 0xd34a789b }, + { "NvAPI_VIO_SetConfig", 0x0e4eec07 }, + { "NvAPI_VIO_SetCSC", 0xa1ec8d74 }, + { "NvAPI_VIO_GetCSC", 0x7b0d72a3 }, + { "NvAPI_VIO_SetGamma", 0x964bf452 }, + { "NvAPI_VIO_GetGamma", 0x51d53d06 }, + { "NvAPI_VIO_SetSyncDelay", 0x2697a8d1 }, + { "NvAPI_VIO_GetSyncDelay", 0x462214a9 }, + { "NvAPI_VIO_GetPCIInfo", 0xb981d935 }, + { "NvAPI_VIO_IsRunning", 0x96bd040e }, + { "NvAPI_VIO_Start", 0xcde8e1a3 }, + { "NvAPI_VIO_Stop", 0x6ba2a5d6 }, + { "NvAPI_VIO_IsFrameLockModeCompatible", 0x7bf0a94d }, + { "NvAPI_VIO_EnumDevices", 0xfd7c5557 }, + { "NvAPI_VIO_QueryTopology", 0x869534e2 }, + { "NvAPI_VIO_EnumSignalFormats", 0xead72fe4 }, + { "NvAPI_VIO_EnumDataFormats", 0x221fa8e8 }, + { "NvAPI_Stereo_CreateConfigurationProfileRegistryKey", 0xbe7692ec }, + { "NvAPI_Stereo_DeleteConfigurationProfileRegistryKey", 0xf117b834 }, + { "NvAPI_Stereo_SetConfigurationProfileValue", 0x24409f48 }, + { "NvAPI_Stereo_DeleteConfigurationProfileValue", 0x49bceecf }, + { "NvAPI_Stereo_Enable", 0x239c4545 }, + { "NvAPI_Stereo_Disable", 0x2ec50c2b }, + { "NvAPI_Stereo_IsEnabled", 0x348ff8e1 }, + { "NvAPI_Stereo_GetStereoSupport", 0x296c434d }, + { "NvAPI_Stereo_CreateHandleFromIUnknown", 0xac7e37f4 }, + { "NvAPI_Stereo_DestroyHandle", 0x3a153134 }, + { "NvAPI_Stereo_Activate", 0xf6a1ad68 }, + { "NvAPI_Stereo_Deactivate", 0x2d68de96 }, + { "NvAPI_Stereo_IsActivated", 0x1fb0bc30 }, + { "NvAPI_Stereo_GetSeparation", 0x451f2134 }, + { "NvAPI_Stereo_SetSeparation", 0x5c069fa3 }, + { "NvAPI_Stereo_DecreaseSeparation", 0xda044458 }, + { "NvAPI_Stereo_IncreaseSeparation", 0xc9a8ecec }, + { "NvAPI_Stereo_GetConvergence", 0x4ab00934 }, + { "NvAPI_Stereo_SetConvergence", 0x3dd6b54b }, + { "NvAPI_Stereo_DecreaseConvergence", 0x4c87e317 }, + { "NvAPI_Stereo_IncreaseConvergence", 0xa17daabe }, + { "NvAPI_Stereo_GetFrustumAdjustMode", 0xe6839b43 }, + { "NvAPI_Stereo_SetFrustumAdjustMode", 0x7be27fa2 }, + { "NvAPI_Stereo_CaptureJpegImage", 0x932cb140 }, + { "NvAPI_Stereo_InitActivation", 0xc7177702 }, + { "NvAPI_Stereo_Trigger_Activation", 0x0d6c6cd2 }, + { "NvAPI_Stereo_CapturePngImage", 0x8b7e99b5 }, + { "NvAPI_Stereo_ReverseStereoBlitControl", 0x3cd58f89 }, + { "NvAPI_Stereo_SetNotificationMessage", 0x6b9b409e }, + { "NvAPI_Stereo_SetActiveEye", 0x96eea9f8 }, + { "NvAPI_Stereo_SetDriverMode", 0x5e8f0bec }, + { "NvAPI_Stereo_GetEyeSeparation", 0xce653127 }, + { "NvAPI_Stereo_IsWindowedModeSupported", 0x40c8ed5e }, + { "NvAPI_Stereo_SetSurfaceCreationMode", 0xf5dcfcba }, + { "NvAPI_Stereo_GetSurfaceCreationMode", 0x36f1c736 }, + { "NvAPI_Stereo_Debug_WasLastDrawStereoized", 0xed4416c5 }, + { "NvAPI_Stereo_SetDefaultProfile", 0x44f0ecd1 }, + { "NvAPI_Stereo_GetDefaultProfile", 0x624e21c2 }, + { "NvAPI_D3D1x_CreateSwapChain", 0x1bc21b66 }, + { "NvAPI_D3D9_CreateSwapChain", 0x1a131e09 }, + { "NvAPI_Vulkan_InitLowLatencyDevice", 0x5c1696b6 }, + { "NvAPI_Vulkan_DestroyLowLatencyDevice", 0x11a5932b }, + { "NvAPI_Vulkan_GetSleepStatus", 0xadf966af }, + { "NvAPI_Vulkan_SetSleepMode", 0x2acfd162 }, + { "NvAPI_Vulkan_Sleep", 0x36732b1e }, + { "NvAPI_Vulkan_GetLatency", 0x3233d44a }, + { "NvAPI_Vulkan_SetLatencyMarker", 0xa17d13d6 }, + { "NvAPI_Vulkan_NotifyOutOfBandVkQueue", 0x5d6d3840 }, + { "NvAPI_DRS_CreateSession", 0x0694d52e }, + { "NvAPI_DRS_DestroySession", 0xdad9cff8 }, + { "NvAPI_DRS_LoadSettings", 0x375dbd6b }, + { "NvAPI_DRS_SaveSettings", 0xfcbc7e14 }, + { "NvAPI_DRS_LoadSettingsFromFile", 0xd3ede889 }, + { "NvAPI_DRS_SaveSettingsToFile", 0x2be25df8 }, + { "NvAPI_DRS_CreateProfile", 0xcc176068 }, + { "NvAPI_DRS_DeleteProfile", 0x17093206 }, + { "NvAPI_DRS_SetCurrentGlobalProfile", 0x1c89c5df }, + { "NvAPI_DRS_GetCurrentGlobalProfile", 0x617bff9f }, + { "NvAPI_DRS_GetProfileInfo", 0x61cd6fd6 }, + { "NvAPI_DRS_SetProfileInfo", 0x16abd3a9 }, + { "NvAPI_DRS_FindProfileByName", 0x7e4a9a0b }, + { "NvAPI_DRS_EnumProfiles", 0xbc371ee0 }, + { "NvAPI_DRS_GetNumProfiles", 0x1dae4fbc }, + { "NvAPI_DRS_CreateApplication", 0x4347a9de }, + { "NvAPI_DRS_DeleteApplicationEx", 0xc5ea85a1 }, + { "NvAPI_DRS_DeleteApplication", 0x2c694bc6 }, + { "NvAPI_DRS_GetApplicationInfo", 0xed1f8c69 }, + { "NvAPI_DRS_EnumApplications", 0x7fa2173a }, + { "NvAPI_DRS_FindApplicationByName", 0xeee566b2 }, + { "NvAPI_DRS_SetSetting", 0x577dd202 }, + { "NvAPI_DRS_GetSetting", 0x73bf8338 }, + { "NvAPI_DRS_EnumSettings", 0xae3039da }, + { "NvAPI_DRS_EnumAvailableSettingIds", 0xf020614a }, + { "NvAPI_DRS_EnumAvailableSettingValues", 0x2ec39f90 }, + { "NvAPI_DRS_GetSettingIdFromName", 0xcb7309cd }, + { "NvAPI_DRS_GetSettingNameFromId", 0xd61cbe6e }, + { "NvAPI_DRS_DeleteProfileSetting", 0xe4a26362 }, + { "NvAPI_DRS_RestoreAllDefaults", 0x5927b094 }, + { "NvAPI_DRS_RestoreProfileDefault", 0xfa5f6134 }, + { "NvAPI_DRS_RestoreProfileDefaultSetting", 0x53f0381e }, + { "NvAPI_DRS_GetBaseProfile", 0xda8466a0 }, + { "NvAPI_SYS_GetChipSetInfo", 0x53dabbca }, + { "NvAPI_SYS_GetLidAndDockInfo", 0xcda14d8a }, + { "NvAPI_SYS_GetDisplayIdFromGpuAndOutputId", 0x08f2bab4 }, + { "NvAPI_SYS_GetGpuAndOutputIdFromDisplayId", 0x112ba1a5 }, + { "NvAPI_SYS_GetPhysicalGpuFromDisplayId", 0x9ea74659 }, + { "NvAPI_SYS_GetDisplayDriverInfo", 0x721faceb }, + { "NvAPI_SYS_GetPhysicalGPUs", 0xd3b24d2d }, + { "NvAPI_SYS_GetLogicalGPUs", 0xccfffc10 }, + { "NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates", 0xadeeaf67 }, + { "NvAPI_RegisterRiseCallback", 0x9cfe8f94 }, + { "NvAPI_RequestRise", 0x5047de98 }, + { "NvAPI_UninstallRise", 0xab8d09f6 }, +}; + +#endif // _NVAPI_INTERFACE_H