Skip to content

Commit

Permalink
Version 2.0
Browse files Browse the repository at this point in the history
  • Loading branch information
@RavenSystem
RavenSystem committed Nov 28, 2023
1 parent f685a7f commit c0f705b
Show file tree
Hide file tree
Showing 19 changed files with 1,115 additions and 98 deletions.
26 changes: 26 additions & 0 deletions CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,20 @@ macro(set_compute_shader FILE OUT_FILE VAR_NAME)
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_VARIABLE_NAME "${VAR_NAME}")
endmacro()

macro(set_pixel_shader FILE OUT_FILE VAR_NAME)
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_TYPE "Pixel")
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_MODEL "5.0")
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_OUTPUT_HEADER_FILE "${OUT_FILE}")
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_VARIABLE_NAME "${VAR_NAME}")
endmacro()

macro(set_vertex_shader FILE OUT_FILE VAR_NAME)
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_TYPE "Vertex")
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_MODEL "5.0")
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_OUTPUT_HEADER_FILE "${OUT_FILE}")
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_VARIABLE_NAME "${VAR_NAME}")
endmacro()

set(RESOURCE_FILES
resources/exports.def
)
Expand Down Expand Up @@ -102,6 +116,14 @@ source_group("cas" FILES ${CAS_FILES})
set_compute_shader(src/cas/cas.sharpen.hlsl "shader_cas_sharpen.h" "g_CASSharpenShader")
set_compute_shader(src/cas/cas.upscale.hlsl "shader_cas_upscale.h" "g_CASUpscaleShader")

set(HRM_FILES
src/hrm/hidden_radial_mask.hlsl
src/hrm/fullscreen_tri.vert.hlsl
)
source_group("hrm" FILES ${HRM_FILES})
set_pixel_shader(src/hrm/hidden_radial_mask.hlsl "shader_hrm_mask.h" "g_HRM_MaskShader")
set_vertex_shader(src/hrm/fullscreen_tri.vert.hlsl "shader_hrm_fullscreen_tri.h" "g_HRM_FullscreenTriShader")

set(MAIN_FILES
src/config.h
src/config.cpp
Expand All @@ -127,6 +149,7 @@ set(PROJECT_FILES
${FSR_FILES}
${NIS_FILES}
${CAS_FILES}
${HRM_FILES}
${MAIN_FILES}
)

Expand Down Expand Up @@ -159,3 +182,6 @@ endif()
add_library(vrperfkit SHARED ${PROJECT_FILES})
set_target_properties(vrperfkit PROPERTIES OUTPUT_NAME "dxgi")
target_link_libraries(vrperfkit minhook yaml-cpp dxguid ${NVAPI_LIB})

string(REPLACE "/Ob2" "/Ob3" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
message(CMAKE_CXX_FLAGS_RELEASE="${CMAKE_CXX_FLAGS_RELEASE}")
13 changes: 5 additions & 8 deletions README.md
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
VR Performance Toolkit RavenSystem's Fork
=========================================

In an effort to continue this project, I have created this fork with updated components and SDKs.
In an effort to continue this project, I have created this fork with updated components and SDKs. I added too some
improvements, like HRM and dynamic modes, and other compatibility options.

Performance-oriented collection of mods for VR games.

Expand All @@ -11,15 +12,11 @@ Included mods:
* AMD FidelityFX Super Resolution
* NVIDIA Image Scaling
* AMD Contrast Adaptive Sharpening
* Fixed foveated rendering (render center of image at full resolution, but drop resolution towards edges)
* FFR: Fixed foveated rendering (render center of image at full resolution, but drop resolution towards edges)
* Variable Rate Shading (only for NVIDIA RTX / GTX 16xx cards)

Planned mods:

* "Fixed foveated" rendering (render fewer pixels at the edges of the screen)
* Radial Density Masking (all GPUs, but works only with a handful of games)
* Force hidden area mask: don't render pixels at the edges that are not visible in the headset.
* HRM: Hidden radial mask: don't render pixels at the edges that are not visible in the headset.
Many games already use this mask, but not all. This mod will allow you to force its usage.
* Dynamic modes for FFR and HRM to apply only to keep target FPS.

Supported VR runtimes:

Expand Down
138 changes: 124 additions & 14 deletions src/config.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,8 +19,8 @@ namespace vrperfkit {
if (s == "cas") {
return UpscaleMethod::CAS;
}
LOG_INFO << "Unknown upscaling method " << s << ", defaulting to FSR";
return UpscaleMethod::FSR;
LOG_INFO << "Unknown upscaling method " << s << ", defaulting to NIS";
return UpscaleMethod::NIS;
}

std::string MethodToString(UpscaleMethod method) {
Expand Down Expand Up @@ -50,6 +50,37 @@ namespace vrperfkit {
}
}

GameMode GameModeFromString(std::string s) {
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
if (s == "auto") {
return GameMode::AUTO;
}
if (s == "single") {
return GameMode::GENERIC_SINGLE;
}
if (s == "left") {
return GameMode::LEFT_EYE_FIRST;
}
if (s == "right") {
return GameMode::RIGHT_EYE_FIRST;
}
LOG_INFO << "Unknown HRM Mode " << s << ", defaulting to auto";
return GameMode::AUTO;
}

std::string GameModeToString(GameMode mode) {
switch (mode) {
case GameMode::AUTO:
return "auto";
case GameMode::GENERIC_SINGLE:
return "single";
case GameMode::LEFT_EYE_FIRST:
return "left";
case GameMode::RIGHT_EYE_FIRST:
return "right";
}
}

std::string PrintToggle(bool toggle) {
return toggle ? "enabled" : "disabled";
}
Expand All @@ -72,9 +103,9 @@ namespace vrperfkit {
UpscaleConfig &upscaling= g_config.upscaling;
upscaling.enabled = upscaleCfg["enabled"].as<bool>(upscaling.enabled);
upscaling.method = MethodFromString(upscaleCfg["method"].as<std::string>(MethodToString(upscaling.method)));
upscaling.renderScale = upscaleCfg["renderScale"].as<float>(upscaling.renderScale);
upscaling.renderScale = sqrt(upscaleCfg["renderScale"].as<float>(upscaling.renderScale) / 100.00f);
if (upscaling.renderScale < 0.5f) {
LOG_INFO << "Setting render scale to minimum value of 0.5";
LOG_INFO << "Setting render scale to minimum value of 25%";
upscaling.renderScale = 0.5f;
}
upscaling.sharpness = std::max(0.f, upscaleCfg["sharpness"].as<float>(upscaling.sharpness));
Expand All @@ -90,15 +121,48 @@ namespace vrperfkit {
YAML::Node ffrCfg = cfg["fixedFoveated"];
FixedFoveatedConfig &ffr = g_config.ffr;
ffr.enabled = ffrCfg["enabled"].as<bool>(ffr.enabled);
ffr.apply = ffr.enabled;
ffr.favorHorizontal = ffrCfg["favorHorizontal"].as<bool>(ffr.favorHorizontal);
ffr.innerRadius = ffrCfg["innerRadius"].as<float>(ffr.innerRadius);
ffr.midRadius = ffrCfg["midRadius"].as<float>(ffr.midRadius);
ffr.outerRadius = ffrCfg["outerRadius"].as<float>(ffr.outerRadius);
ffr.preciseResolution = ffrCfg["preciseResolution"].as<bool>(ffr.preciseResolution);
ffr.ignoreFirstTargetRenders = ffrCfg["ignoreFirstTargetRenders"].as<int>(ffr.ignoreFirstTargetRenders);
ffr.maxRadius = ffr.innerRadius;
ffr.overrideSingleEyeOrder = ffrCfg["overrideSingleEyeOrder"].as<std::string>(ffr.overrideSingleEyeOrder);
ffr.fastMode = ffrCfg["fastMode"].as<bool>(ffr.fastMode);
ffr.dynamic = ffrCfg["dynamic"].as<bool>(ffr.dynamic);
ffr.targetFrameTime = 1.f / ffrCfg["targetFPS"].as<float>(ffr.targetFrameTime);
ffr.marginFrameTime = 1.f / ffrCfg["marginFPS"].as<float>(ffr.marginFrameTime);
ffr.dynamicChangeRadius= ffrCfg["dynamicChangeRadius"].as<bool>(ffr.dynamicChangeRadius);
ffr.minRadius = ffrCfg["minRadius"].as<float>(ffr.minRadius);
ffr.increaseRadiusStep = ffrCfg["increaseRadiusStep"].as<float>(ffr.increaseRadiusStep);
ffr.decreaseRadiusStep = ffrCfg["decreaseRadiusStep"].as<float>(ffr.decreaseRadiusStep);

YAML::Node hiddenMaskCfg = cfg["hiddenMask"];
HiddenRadialMask &hiddenMask= g_config.hiddenMask;
hiddenMask.enabled = hiddenMaskCfg["enabled"].as<bool>(hiddenMask.enabled);
hiddenMask.radius = std::max(0.f, hiddenMaskCfg["radius"].as<float>(hiddenMask.radius));
hiddenMask.maxRadius = hiddenMask.radius;
hiddenMask.preciseResolution = hiddenMaskCfg["preciseResolution"].as<bool>(hiddenMask.preciseResolution);
hiddenMask.ignoreFirstTargetRenders = hiddenMaskCfg["ignoreFirstTargetRenders"].as<int>(hiddenMask.ignoreFirstTargetRenders);
hiddenMask.dynamic = hiddenMaskCfg["dynamic"].as<bool>(hiddenMask.dynamic);
hiddenMask.targetFrameTime = 1.f / hiddenMaskCfg["targetFPS"].as<float>(hiddenMask.targetFrameTime);
hiddenMask.marginFrameTime = 1.f / hiddenMaskCfg["marginFPS"].as<float>(hiddenMask.marginFrameTime);
hiddenMask.dynamicChangeRadius = hiddenMaskCfg["dynamicChangeRadius"].as<bool>(hiddenMask.dynamicChangeRadius);
hiddenMask.minRadius = hiddenMaskCfg["minRadius"].as<float>(hiddenMask.minRadius);
hiddenMask.increaseRadiusStep = hiddenMaskCfg["increaseRadiusStep"].as<float>(hiddenMask.increaseRadiusStep);
hiddenMask.decreaseRadiusStep = hiddenMaskCfg["decreaseRadiusStep"].as<float>(hiddenMask.decreaseRadiusStep);

g_config.debugMode = cfg["debugMode"].as<bool>(g_config.debugMode);

g_config.dllLoadPath = cfg["dllLoadPath"].as<std::string>(g_config.dllLoadPath);

g_config.gameMode = GameModeFromString(cfg["gameMode"].as<std::string>(GameModeToString(g_config.gameMode)));
g_config.dynamicFramesCheck = cfg["dynamicFramesCheck"].as<int>(g_config.dynamicFramesCheck);
if (g_config.dynamicFramesCheck < 1) {
g_config.dynamicFramesCheck = 1;
}
}
catch (const YAML::Exception &e) {
LOG_ERROR << "Failed to load configuration file: " << e.msg;
Expand All @@ -107,21 +171,67 @@ namespace vrperfkit {

void PrintCurrentConfig() {
LOG_INFO << "Current configuration:";
LOG_INFO << " Upscaling (" << MethodToString(g_config.upscaling.method) << ") is " << PrintToggle(g_config.upscaling.enabled);
LOG_INFO << " Upscaling is " << PrintToggle(g_config.upscaling.enabled);
if (g_config.upscaling.enabled) {
LOG_INFO << " * Render scale: " << std::setprecision(2) << g_config.upscaling.renderScale;
LOG_INFO << " * Sharpness: " << std::setprecision(2) << g_config.upscaling.sharpness;
LOG_INFO << " * Radius: " << std::setprecision(2) << g_config.upscaling.radius;
LOG_INFO << " * MIP bias: " << PrintToggle(g_config.upscaling.applyMipBias);
LOG_INFO << " * Method: " << MethodToString(g_config.upscaling.method);
LOG_INFO << " * Render scale: " << std::setprecision(6) << g_config.upscaling.renderScale * g_config.upscaling.renderScale * 100 << "%";
LOG_INFO << " * Render factor: " << std::setprecision(6) << g_config.upscaling.renderScale;
LOG_INFO << " * Sharpness: " << std::setprecision(6) << g_config.upscaling.sharpness;
LOG_INFO << " * Radius: " << std::setprecision(6) << g_config.upscaling.radius;
LOG_INFO << " * MIP bias: " << PrintToggle(g_config.upscaling.applyMipBias);
}
LOG_INFO << " Fixed foveated rendering (" << FFRMethodToString(g_config.ffr.method) << ") is " << PrintToggle(g_config.ffr.enabled);
LOG_INFO << " Game Mode: " << GameModeToString(g_config.gameMode);
if ((g_config.ffr.enabled && g_config.ffr.dynamic) || (g_config.hiddenMask.enabled && g_config.hiddenMask.dynamic)) {
LOG_INFO << " Dynamic Frames Check: " << std::setprecision(6) << g_config.dynamicFramesCheck;
}
LOG_INFO << " Fixed foveated rendering is " << PrintToggle(g_config.ffr.enabled);
if (g_config.ffr.enabled) {
LOG_INFO << " * Inner radius: " << std::setprecision(2) << g_config.ffr.innerRadius;
LOG_INFO << " * Mid radius: " << std::setprecision(2) << g_config.ffr.midRadius;
LOG_INFO << " * Outer radius: " << std::setprecision(2) << g_config.ffr.outerRadius;
LOG_INFO << " * Method: " << FFRMethodToString(g_config.ffr.method);
LOG_INFO << " * Inner radius: " << std::setprecision(6) << g_config.ffr.innerRadius;
LOG_INFO << " * Mid radius: " << std::setprecision(6) << g_config.ffr.midRadius;
LOG_INFO << " * Outer radius: " << std::setprecision(6) << g_config.ffr.outerRadius;
LOG_INFO << " * Precise res: " << PrintToggle(g_config.ffr.preciseResolution);
LOG_INFO << " * No renders: " << std::setprecision(6) << g_config.ffr.ignoreFirstTargetRenders;
if (!g_config.ffr.overrideSingleEyeOrder.empty()) {
LOG_INFO << " * Eye order: " << g_config.ffr.overrideSingleEyeOrder;
LOG_INFO << " * Eye order: " << g_config.ffr.overrideSingleEyeOrder;
}
LOG_INFO << " * Fast mode: " << PrintToggle(g_config.ffr.fastMode);
LOG_INFO << " * Dynamic: " << PrintToggle(g_config.ffr.dynamic);
if (g_config.ffr.dynamic) {
LOG_INFO << " * Target FPS: " << std::setprecision(6) << (1.f / g_config.ffr.targetFrameTime);
LOG_INFO << " * Target FT: " << std::setprecision(6) << (g_config.ffr.targetFrameTime * 1000.f) << "ms";
LOG_INFO << " * Margin FPS: " << std::setprecision(6) << (1.f / g_config.ffr.marginFrameTime);
LOG_INFO << " * Margin FT: " << std::setprecision(6) << (g_config.ffr.marginFrameTime * 1000.f) << "ms";
LOG_INFO << " * Change radius is " << PrintToggle(g_config.ffr.dynamicChangeRadius);
if (g_config.ffr.dynamicChangeRadius) {
LOG_INFO << " * Min radius: " << std::setprecision(6) << g_config.ffr.minRadius;
LOG_INFO << " * Inc radius: " << std::setprecision(6) << g_config.ffr.increaseRadiusStep;
LOG_INFO << " * Dec radius: " << std::setprecision(6) << g_config.ffr.decreaseRadiusStep;
}
}
} else {
g_config.ffr.dynamic = false;
}
LOG_INFO << " Hidden radial mask is " << PrintToggle(g_config.hiddenMask.enabled);
if (g_config.hiddenMask.enabled) {
LOG_INFO << " * Radius: " << std::setprecision(6) << g_config.hiddenMask.radius;
LOG_INFO << " * Precise res: " << PrintToggle(g_config.hiddenMask.preciseResolution);
LOG_INFO << " * No renders: " << std::setprecision(6) << g_config.hiddenMask.ignoreFirstTargetRenders;
LOG_INFO << " * Dynamic: " << PrintToggle(g_config.hiddenMask.dynamic);
if (g_config.hiddenMask.dynamic) {
LOG_INFO << " * Target FPS: " << std::setprecision(6) << (1.f / g_config.hiddenMask.targetFrameTime);
LOG_INFO << " * Target FT: " << std::setprecision(6) << (g_config.hiddenMask.targetFrameTime * 1000.f) << "ms";
LOG_INFO << " * Margin FPS: " << std::setprecision(6) << (1.f / g_config.hiddenMask.marginFrameTime);
LOG_INFO << " * Margin FT: " << std::setprecision(6) << (g_config.hiddenMask.marginFrameTime * 1000.f) << "ms";
LOG_INFO << " * Change radius is " << PrintToggle(g_config.hiddenMask.dynamicChangeRadius);
if (g_config.hiddenMask.dynamicChangeRadius) {
LOG_INFO << " - Min radius: " << std::setprecision(6) << g_config.hiddenMask.minRadius;
LOG_INFO << " - Inc radius: " << std::setprecision(6) << g_config.hiddenMask.increaseRadiusStep;
LOG_INFO << " - Dec radius: " << std::setprecision(6) << g_config.hiddenMask.decreaseRadiusStep;
}
}
} else {
g_config.hiddenMask.dynamic = false;
}
LOG_INFO << " Debug mode is " << PrintToggle(g_config.debugMode);
FlushLog();
Expand Down
45 changes: 39 additions & 6 deletions src/config.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,9 +7,9 @@ namespace vrperfkit {
struct UpscaleConfig {
bool enabled = false;
UpscaleMethod method = UpscaleMethod::NIS;
float renderScale = 0.866f;
float sharpness = 0.20f;
float radius = 1.00f;
float renderScale = 0.83667f;
float sharpness = 0.30f;
float radius = 0.95f;
bool applyMipBias = true;
};

Expand All @@ -24,20 +24,53 @@ namespace vrperfkit {

struct FixedFoveatedConfig {
bool enabled = false;
bool apply = false;
FixedFoveatedMethod method = FixedFoveatedMethod::VRS;
float innerRadius = 0.70f;
float midRadius = 0.85f;
float outerRadius = 1.00f;
float innerRadius = 0.50f;
float midRadius = 0.65f;
float outerRadius = 0.80f;
bool favorHorizontal = true;
std::string overrideSingleEyeOrder;
bool fastMode = false;
bool dynamic = false;
bool dynamicChangeRadius = false;
float targetFrameTime = 0.0167f;
float marginFrameTime = 0.f;
float minRadius = 0.30f;
float maxRadius = 1.15f;
float decreaseRadiusStep = 0.01f;
float increaseRadiusStep = 0.03f;
bool preciseResolution = true;
int ignoreFirstTargetRenders = 0;
bool radiusChanged[2] = { true, true };
};

struct HiddenRadialMask {
bool enabled = false;
float radius = 1.15f;
bool dynamic = false;
bool dynamicChangeRadius = false;
float targetFrameTime = 0.0167f;
float marginFrameTime = 0.f;
float minRadius = 0.8f;
float maxRadius = 1.15f;
float decreaseRadiusStep = 0.01f;
float increaseRadiusStep = 0.03f;
bool preciseResolution = true;
int ignoreFirstTargetRenders = 0;
};

struct Config {
UpscaleConfig upscaling;
DxvkConfig dxvk;
GameMode gameMode = GameMode::AUTO;
bool renderingSecondEye = false;
int ffrDepthClearCount = 0;
FixedFoveatedConfig ffr;
HiddenRadialMask hiddenMask;
bool debugMode = false;
std::string dllLoadPath = "";
int dynamicFramesCheck = 1;
};

extern Config g_config;
Expand Down
Loading

0 comments on commit c0f705b

Please sign in to comment.