mirror of
https://github.com/optiscaler/OptiScaler.git
synced 2026-08-26 08:06:33 +00:00
Rework nvapi code and deal with externally overridden DLSS presets (#199)
* Clean up nvapi * Fix up fakenvapi * Clean up nvapi hooks * Minor fixes * Don't log reflex calls by default * Add warning and config for externally overridden DLSS presets * Add missing value_for_config() * Add support for the "Latest" preset * Fix typo in the config
This commit is contained in:
Michał Lewandowski
+1
-1
@@ -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
|
||||
|
||||
+16
-14
@@ -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
|
||||
|
||||
@@ -415,6 +415,10 @@ copy NUL "$(SolutionDir)x64\Release\a\!! EXTRACT ALL FILES TO GAME FOLDER !!" /Y
|
||||
<ItemGroup>
|
||||
<ClCompile Include="menu\menu_base.cpp" />
|
||||
<ClCompile Include="misc\FrameLimit.cpp" />
|
||||
<ClCompile Include="nvapi\fakenvapi.cpp" />
|
||||
<ClCompile Include="nvapi\NvApiHooks.cpp" />
|
||||
<ClCompile Include="nvapi\NvApiTypes.cpp" />
|
||||
<ClCompile Include="nvapi\ReflexHooks.cpp" />
|
||||
<ClCompile Include="shaders\depth_scale\DS_Dx12.cpp" />
|
||||
<ClCompile Include="upscalers\dlssd\DLSSDFeature.cpp" />
|
||||
<ClCompile Include="upscalers\dlssd\DLSSDFeature_Dx11.cpp" />
|
||||
|
||||
@@ -608,6 +608,18 @@
|
||||
<ClCompile Include="misc\FrameLimit.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="nvapi\ReflexHooks.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="nvapi\NvApiTypes.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="nvapi\fakenvapi.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="nvapi\NvApiHooks.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ResourceCompile Include="OptiScaler.rc" />
|
||||
|
||||
+3
-1
@@ -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;
|
||||
|
||||
@@ -2,11 +2,12 @@
|
||||
#include "wrapped_swapchain.h"
|
||||
|
||||
#include <Util.h>
|
||||
#include <Logger.h>
|
||||
#include <Config.h>
|
||||
|
||||
#include <menu/menu_overlay_dx.h>
|
||||
#include <detours/detours.h>
|
||||
#include <dx12/ffx_api_dx12.h>
|
||||
#include <ffx_framegeneration.h>
|
||||
|
||||
#include <d3d11on12.h>
|
||||
|
||||
@@ -16,6 +17,8 @@
|
||||
#include <set>
|
||||
#include <future>
|
||||
|
||||
#include "nvapi/ReflexHooks.h"
|
||||
|
||||
// Clear heap info when ResourceDiscard is called
|
||||
//#define USE_RESOURCE_DISCARD
|
||||
|
||||
|
||||
@@ -29,9 +29,6 @@
|
||||
|
||||
#include <proxies/FfxApi_Proxy.h>
|
||||
#include <nvapi/fakenvapi.h>
|
||||
#include <nvapi/ReflexHooks.h>
|
||||
#include <dx12/ffx_api_dx12.h>
|
||||
#include <ffx_framegeneration.h>
|
||||
|
||||
namespace HooksDx
|
||||
{
|
||||
|
||||
@@ -695,7 +695,8 @@ template <HasDefaultValue B>
|
||||
void MenuCommon::AddRenderPreset(std::string name, CustomOptional<uint32_t, B>* 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<uint32_t, B>*
|
||||
"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 <HasDefaultValue B>
|
||||
@@ -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))
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
#include "NvApiHooks.h"
|
||||
#include <NvApiDriverSettings.h>
|
||||
#include "State.h"
|
||||
#include <detours/detours.h>
|
||||
#include <Config.h>
|
||||
|
||||
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<decltype(&NvAPI_GPU_GetArchInfo)>(functionPointer);
|
||||
return &hkNvAPI_GPU_GetArchInfo;
|
||||
}
|
||||
if (InterfaceId == GET_ID(NvAPI_DRS_GetSetting))
|
||||
{
|
||||
o_NvAPI_DRS_GetSetting = static_cast<decltype(&NvAPI_DRS_GetSetting)>(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();
|
||||
}
|
||||
@@ -1,142 +1,19 @@
|
||||
#pragma once
|
||||
|
||||
#include <pch.h>
|
||||
#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<NvApiTypes::PfnNvAPI_GPU_GetArchInfo>(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();
|
||||
};
|
||||
@@ -0,0 +1,32 @@
|
||||
#include "NvApiTypes.h"
|
||||
|
||||
#include <nvapi_interface.h>
|
||||
|
||||
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;
|
||||
}
|
||||
@@ -5,21 +5,19 @@
|
||||
#include <d3d12.h>
|
||||
#include <nvapi.h>
|
||||
|
||||
#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<std::string, unsigned int> 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;
|
||||
};
|
||||
|
||||
@@ -0,0 +1,206 @@
|
||||
#include "ReflexHooks.h"
|
||||
#include <Config.h>
|
||||
|
||||
#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<decltype(&NvAPI_D3D_SetSleepMode)>(queryInterface(GET_ID(NvAPI_D3D_SetSleepMode)));
|
||||
o_NvAPI_D3D_Sleep = static_cast<decltype(&NvAPI_D3D_Sleep)>(queryInterface(GET_ID(NvAPI_D3D_Sleep)));
|
||||
o_NvAPI_D3D_GetLatency = static_cast<decltype(&NvAPI_D3D_GetLatency)>(queryInterface(GET_ID(NvAPI_D3D_GetLatency)));
|
||||
o_NvAPI_D3D_SetLatencyMarker = static_cast<decltype(&NvAPI_D3D_SetLatencyMarker)>(queryInterface(GET_ID(NvAPI_D3D_SetLatencyMarker)));
|
||||
o_NvAPI_D3D12_SetAsyncFrameMarker = static_cast<decltype(&NvAPI_D3D12_SetAsyncFrameMarker)>(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<uint32_t>(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);
|
||||
}
|
||||
|
||||
}
|
||||
+12
-205
@@ -1,7 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
#include <State.h>
|
||||
#include "fakenvapi.h"
|
||||
#include <d3d12.h>
|
||||
#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<decltype(&NvAPI_D3D_SetSleepMode)>(queryInterface(NvApiTypes::NV_INTERFACE::D3D_SetSleepMode));
|
||||
o_NvAPI_D3D_Sleep = static_cast<decltype(&NvAPI_D3D_Sleep)>(queryInterface(NvApiTypes::NV_INTERFACE::D3D_Sleep));
|
||||
o_NvAPI_D3D_GetLatency = static_cast<decltype(&NvAPI_D3D_GetLatency)>(queryInterface(NvApiTypes::NV_INTERFACE::D3D_GetLatency));
|
||||
o_NvAPI_D3D_SetLatencyMarker = static_cast<decltype(&NvAPI_D3D_SetLatencyMarker)>(queryInterface(NvApiTypes::NV_INTERFACE::D3D_SetLatencyMarker));
|
||||
o_NvAPI_D3D12_SetAsyncFrameMarker = static_cast<decltype(&NvAPI_D3D12_SetAsyncFrameMarker)>(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<uint32_t>(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);
|
||||
};
|
||||
@@ -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<PFN_Fake_InformFGState>(queryInterface(GET_ID(Fake_InformFGState)));
|
||||
Fake_InformPresentFG = static_cast<PFN_Fake_InformPresentFG>(queryInterface(GET_ID(Fake_InformPresentFG)));
|
||||
Fake_GetAntiLagCtx = static_cast<PFN_Fake_GetAntiLagCtx>(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;
|
||||
}
|
||||
@@ -1,22 +1,10 @@
|
||||
#pragma once
|
||||
|
||||
#include <proxies/FfxApi_Proxy.h>
|
||||
#include <dxgi.h>
|
||||
|
||||
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<PFN_Fake_InformFGState>(queryInterface(FN_INTERFACE::Fake_InformFGState));
|
||||
Fake_InformPresentFG = static_cast<PFN_Fake_InformPresentFG>(queryInterface(FN_INTERFACE::Fake_InformPresentFG));
|
||||
Fake_GetAntiLagCtx = static_cast<PFN_Fake_GetAntiLagCtx>(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;
|
||||
}
|
||||
};
|
||||
static void Init(PFN_NvApi_QueryInterface& queryInterface);
|
||||
static void reportFGPresent(IDXGISwapChain* pSwapChain, bool fg_state, bool frame_interpolated);
|
||||
static bool isUsingFakenvapi();
|
||||
};
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <upscalers/IFeature_Dx11wDx12.h>
|
||||
|
||||
#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);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <upscalers/IFeature_Dx12.h>
|
||||
|
||||
#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);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <upscalers/IFeature_Vk.h>
|
||||
|
||||
#include "vk/ffx_api_vk.h"
|
||||
#include <proxies/FfxApi_Proxy.h>
|
||||
|
||||
class FSR31FeatureVk : public FSR31Feature, public IFeature_Vk
|
||||
{
|
||||
|
||||
Vendored
+1322
File diff suppressed because it is too large
Load Diff
Vendored
+546
@@ -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
|
||||
Reference in New Issue
Block a user