Skip to content

Commit c0f705b

Browse files
RavenSystemRavenSystem
committed
Version 2.0
1 parent f685a7f commit c0f705b

19 files changed

Lines changed: 1115 additions & 98 deletions

‎CMakeLists.txt‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,20 @@ macro(set_compute_shader FILE OUT_FILE VAR_NAME)
2222
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_VARIABLE_NAME "${VAR_NAME}")
2323
endmacro()
2424

25+
macro(set_pixel_shader FILE OUT_FILE VAR_NAME)
26+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_TYPE "Pixel")
27+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_MODEL "5.0")
28+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_OUTPUT_HEADER_FILE "${OUT_FILE}")
29+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_VARIABLE_NAME "${VAR_NAME}")
30+
endmacro()
31+
32+
macro(set_vertex_shader FILE OUT_FILE VAR_NAME)
33+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_TYPE "Vertex")
34+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_MODEL "5.0")
35+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_OUTPUT_HEADER_FILE "${OUT_FILE}")
36+
set_property(SOURCE ${FILE} PROPERTY VS_SHADER_VARIABLE_NAME "${VAR_NAME}")
37+
endmacro()
38+
2539
set(RESOURCE_FILES
2640
resources/exports.def
2741
)
@@ -102,6 +116,14 @@ source_group("cas" FILES ${CAS_FILES})
102116
set_compute_shader(src/cas/cas.sharpen.hlsl "shader_cas_sharpen.h" "g_CASSharpenShader")
103117
set_compute_shader(src/cas/cas.upscale.hlsl "shader_cas_upscale.h" "g_CASUpscaleShader")
104118

119+
set(HRM_FILES
120+
src/hrm/hidden_radial_mask.hlsl
121+
src/hrm/fullscreen_tri.vert.hlsl
122+
)
123+
source_group("hrm" FILES ${HRM_FILES})
124+
set_pixel_shader(src/hrm/hidden_radial_mask.hlsl "shader_hrm_mask.h" "g_HRM_MaskShader")
125+
set_vertex_shader(src/hrm/fullscreen_tri.vert.hlsl "shader_hrm_fullscreen_tri.h" "g_HRM_FullscreenTriShader")
126+
105127
set(MAIN_FILES
106128
src/config.h
107129
src/config.cpp
@@ -127,6 +149,7 @@ set(PROJECT_FILES
127149
${FSR_FILES}
128150
${NIS_FILES}
129151
${CAS_FILES}
152+
${HRM_FILES}
130153
${MAIN_FILES}
131154
)
132155

@@ -159,3 +182,6 @@ endif()
159182
add_library(vrperfkit SHARED ${PROJECT_FILES})
160183
set_target_properties(vrperfkit PROPERTIES OUTPUT_NAME "dxgi")
161184
target_link_libraries(vrperfkit minhook yaml-cpp dxguid ${NVAPI_LIB})
185+
186+
string(REPLACE "/Ob2" "/Ob3" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
187+
message(CMAKE_CXX_FLAGS_RELEASE="${CMAKE_CXX_FLAGS_RELEASE}")

‎README.md‎

Lines changed: 5 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
VR Performance Toolkit RavenSystem's Fork
22
=========================================
33

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

67
Performance-oriented collection of mods for VR games.
78

@@ -11,15 +12,11 @@ Included mods:
1112
* AMD FidelityFX Super Resolution
1213
* NVIDIA Image Scaling
1314
* AMD Contrast Adaptive Sharpening
14-
* Fixed foveated rendering (render center of image at full resolution, but drop resolution towards edges)
15+
* FFR: Fixed foveated rendering (render center of image at full resolution, but drop resolution towards edges)
1516
* Variable Rate Shading (only for NVIDIA RTX / GTX 16xx cards)
16-
17-
Planned mods:
18-
19-
* "Fixed foveated" rendering (render fewer pixels at the edges of the screen)
20-
* Radial Density Masking (all GPUs, but works only with a handful of games)
21-
* Force hidden area mask: don't render pixels at the edges that are not visible in the headset.
17+
* HRM: Hidden radial mask: don't render pixels at the edges that are not visible in the headset.
2218
Many games already use this mask, but not all. This mod will allow you to force its usage.
19+
* Dynamic modes for FFR and HRM to apply only to keep target FPS.
2320

2421
Supported VR runtimes:
2522

‎src/config.cpp‎

Lines changed: 124 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,8 @@ namespace vrperfkit {
1919
if (s == "cas") {
2020
return UpscaleMethod::CAS;
2121
}
22-
LOG_INFO << "Unknown upscaling method " << s << ", defaulting to FSR";
23-
return UpscaleMethod::FSR;
22+
LOG_INFO << "Unknown upscaling method " << s << ", defaulting to NIS";
23+
return UpscaleMethod::NIS;
2424
}
2525

2626
std::string MethodToString(UpscaleMethod method) {
@@ -50,6 +50,37 @@ namespace vrperfkit {
5050
}
5151
}
5252

53+
GameMode GameModeFromString(std::string s) {
54+
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
55+
if (s == "auto") {
56+
return GameMode::AUTO;
57+
}
58+
if (s == "single") {
59+
return GameMode::GENERIC_SINGLE;
60+
}
61+
if (s == "left") {
62+
return GameMode::LEFT_EYE_FIRST;
63+
}
64+
if (s == "right") {
65+
return GameMode::RIGHT_EYE_FIRST;
66+
}
67+
LOG_INFO << "Unknown HRM Mode " << s << ", defaulting to auto";
68+
return GameMode::AUTO;
69+
}
70+
71+
std::string GameModeToString(GameMode mode) {
72+
switch (mode) {
73+
case GameMode::AUTO:
74+
return "auto";
75+
case GameMode::GENERIC_SINGLE:
76+
return "single";
77+
case GameMode::LEFT_EYE_FIRST:
78+
return "left";
79+
case GameMode::RIGHT_EYE_FIRST:
80+
return "right";
81+
}
82+
}
83+
5384
std::string PrintToggle(bool toggle) {
5485
return toggle ? "enabled" : "disabled";
5586
}
@@ -72,9 +103,9 @@ namespace vrperfkit {
72103
UpscaleConfig &upscaling= g_config.upscaling;
73104
upscaling.enabled = upscaleCfg["enabled"].as<bool>(upscaling.enabled);
74105
upscaling.method = MethodFromString(upscaleCfg["method"].as<std::string>(MethodToString(upscaling.method)));
75-
upscaling.renderScale = upscaleCfg["renderScale"].as<float>(upscaling.renderScale);
106+
upscaling.renderScale = sqrt(upscaleCfg["renderScale"].as<float>(upscaling.renderScale) / 100.00f);
76107
if (upscaling.renderScale < 0.5f) {
77-
LOG_INFO << "Setting render scale to minimum value of 0.5";
108+
LOG_INFO << "Setting render scale to minimum value of 25%";
78109
upscaling.renderScale = 0.5f;
79110
}
80111
upscaling.sharpness = std::max(0.f, upscaleCfg["sharpness"].as<float>(upscaling.sharpness));
@@ -90,15 +121,48 @@ namespace vrperfkit {
90121
YAML::Node ffrCfg = cfg["fixedFoveated"];
91122
FixedFoveatedConfig &ffr = g_config.ffr;
92123
ffr.enabled = ffrCfg["enabled"].as<bool>(ffr.enabled);
124+
ffr.apply = ffr.enabled;
93125
ffr.favorHorizontal = ffrCfg["favorHorizontal"].as<bool>(ffr.favorHorizontal);
94126
ffr.innerRadius = ffrCfg["innerRadius"].as<float>(ffr.innerRadius);
95127
ffr.midRadius = ffrCfg["midRadius"].as<float>(ffr.midRadius);
96128
ffr.outerRadius = ffrCfg["outerRadius"].as<float>(ffr.outerRadius);
129+
ffr.preciseResolution = ffrCfg["preciseResolution"].as<bool>(ffr.preciseResolution);
130+
ffr.ignoreFirstTargetRenders = ffrCfg["ignoreFirstTargetRenders"].as<int>(ffr.ignoreFirstTargetRenders);
131+
ffr.maxRadius = ffr.innerRadius;
97132
ffr.overrideSingleEyeOrder = ffrCfg["overrideSingleEyeOrder"].as<std::string>(ffr.overrideSingleEyeOrder);
133+
ffr.fastMode = ffrCfg["fastMode"].as<bool>(ffr.fastMode);
134+
ffr.dynamic = ffrCfg["dynamic"].as<bool>(ffr.dynamic);
135+
ffr.targetFrameTime = 1.f / ffrCfg["targetFPS"].as<float>(ffr.targetFrameTime);
136+
ffr.marginFrameTime = 1.f / ffrCfg["marginFPS"].as<float>(ffr.marginFrameTime);
137+
ffr.dynamicChangeRadius= ffrCfg["dynamicChangeRadius"].as<bool>(ffr.dynamicChangeRadius);
138+
ffr.minRadius = ffrCfg["minRadius"].as<float>(ffr.minRadius);
139+
ffr.increaseRadiusStep = ffrCfg["increaseRadiusStep"].as<float>(ffr.increaseRadiusStep);
140+
ffr.decreaseRadiusStep = ffrCfg["decreaseRadiusStep"].as<float>(ffr.decreaseRadiusStep);
141+
142+
YAML::Node hiddenMaskCfg = cfg["hiddenMask"];
143+
HiddenRadialMask &hiddenMask= g_config.hiddenMask;
144+
hiddenMask.enabled = hiddenMaskCfg["enabled"].as<bool>(hiddenMask.enabled);
145+
hiddenMask.radius = std::max(0.f, hiddenMaskCfg["radius"].as<float>(hiddenMask.radius));
146+
hiddenMask.maxRadius = hiddenMask.radius;
147+
hiddenMask.preciseResolution = hiddenMaskCfg["preciseResolution"].as<bool>(hiddenMask.preciseResolution);
148+
hiddenMask.ignoreFirstTargetRenders = hiddenMaskCfg["ignoreFirstTargetRenders"].as<int>(hiddenMask.ignoreFirstTargetRenders);
149+
hiddenMask.dynamic = hiddenMaskCfg["dynamic"].as<bool>(hiddenMask.dynamic);
150+
hiddenMask.targetFrameTime = 1.f / hiddenMaskCfg["targetFPS"].as<float>(hiddenMask.targetFrameTime);
151+
hiddenMask.marginFrameTime = 1.f / hiddenMaskCfg["marginFPS"].as<float>(hiddenMask.marginFrameTime);
152+
hiddenMask.dynamicChangeRadius = hiddenMaskCfg["dynamicChangeRadius"].as<bool>(hiddenMask.dynamicChangeRadius);
153+
hiddenMask.minRadius = hiddenMaskCfg["minRadius"].as<float>(hiddenMask.minRadius);
154+
hiddenMask.increaseRadiusStep = hiddenMaskCfg["increaseRadiusStep"].as<float>(hiddenMask.increaseRadiusStep);
155+
hiddenMask.decreaseRadiusStep = hiddenMaskCfg["decreaseRadiusStep"].as<float>(hiddenMask.decreaseRadiusStep);
98156

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

101159
g_config.dllLoadPath = cfg["dllLoadPath"].as<std::string>(g_config.dllLoadPath);
160+
161+
g_config.gameMode = GameModeFromString(cfg["gameMode"].as<std::string>(GameModeToString(g_config.gameMode)));
162+
g_config.dynamicFramesCheck = cfg["dynamicFramesCheck"].as<int>(g_config.dynamicFramesCheck);
163+
if (g_config.dynamicFramesCheck < 1) {
164+
g_config.dynamicFramesCheck = 1;
165+
}
102166
}
103167
catch (const YAML::Exception &e) {
104168
LOG_ERROR << "Failed to load configuration file: " << e.msg;
@@ -107,21 +171,67 @@ namespace vrperfkit {
107171

108172
void PrintCurrentConfig() {
109173
LOG_INFO << "Current configuration:";
110-
LOG_INFO << " Upscaling (" << MethodToString(g_config.upscaling.method) << ") is " << PrintToggle(g_config.upscaling.enabled);
174+
LOG_INFO << " Upscaling is " << PrintToggle(g_config.upscaling.enabled);
111175
if (g_config.upscaling.enabled) {
112-
LOG_INFO << " * Render scale: " << std::setprecision(2) << g_config.upscaling.renderScale;
113-
LOG_INFO << " * Sharpness: " << std::setprecision(2) << g_config.upscaling.sharpness;
114-
LOG_INFO << " * Radius: " << std::setprecision(2) << g_config.upscaling.radius;
115-
LOG_INFO << " * MIP bias: " << PrintToggle(g_config.upscaling.applyMipBias);
176+
LOG_INFO << " * Method: " << MethodToString(g_config.upscaling.method);
177+
LOG_INFO << " * Render scale: " << std::setprecision(6) << g_config.upscaling.renderScale * g_config.upscaling.renderScale * 100 << "%";
178+
LOG_INFO << " * Render factor: " << std::setprecision(6) << g_config.upscaling.renderScale;
179+
LOG_INFO << " * Sharpness: " << std::setprecision(6) << g_config.upscaling.sharpness;
180+
LOG_INFO << " * Radius: " << std::setprecision(6) << g_config.upscaling.radius;
181+
LOG_INFO << " * MIP bias: " << PrintToggle(g_config.upscaling.applyMipBias);
116182
}
117-
LOG_INFO << " Fixed foveated rendering (" << FFRMethodToString(g_config.ffr.method) << ") is " << PrintToggle(g_config.ffr.enabled);
183+
LOG_INFO << " Game Mode: " << GameModeToString(g_config.gameMode);
184+
if ((g_config.ffr.enabled && g_config.ffr.dynamic) || (g_config.hiddenMask.enabled && g_config.hiddenMask.dynamic)) {
185+
LOG_INFO << " Dynamic Frames Check: " << std::setprecision(6) << g_config.dynamicFramesCheck;
186+
}
187+
LOG_INFO << " Fixed foveated rendering is " << PrintToggle(g_config.ffr.enabled);
118188
if (g_config.ffr.enabled) {
119-
LOG_INFO << " * Inner radius: " << std::setprecision(2) << g_config.ffr.innerRadius;
120-
LOG_INFO << " * Mid radius: " << std::setprecision(2) << g_config.ffr.midRadius;
121-
LOG_INFO << " * Outer radius: " << std::setprecision(2) << g_config.ffr.outerRadius;
189+
LOG_INFO << " * Method: " << FFRMethodToString(g_config.ffr.method);
190+
LOG_INFO << " * Inner radius: " << std::setprecision(6) << g_config.ffr.innerRadius;
191+
LOG_INFO << " * Mid radius: " << std::setprecision(6) << g_config.ffr.midRadius;
192+
LOG_INFO << " * Outer radius: " << std::setprecision(6) << g_config.ffr.outerRadius;
193+
LOG_INFO << " * Precise res: " << PrintToggle(g_config.ffr.preciseResolution);
194+
LOG_INFO << " * No renders: " << std::setprecision(6) << g_config.ffr.ignoreFirstTargetRenders;
122195
if (!g_config.ffr.overrideSingleEyeOrder.empty()) {
123-
LOG_INFO << " * Eye order: " << g_config.ffr.overrideSingleEyeOrder;
196+
LOG_INFO << " * Eye order: " << g_config.ffr.overrideSingleEyeOrder;
197+
}
198+
LOG_INFO << " * Fast mode: " << PrintToggle(g_config.ffr.fastMode);
199+
LOG_INFO << " * Dynamic: " << PrintToggle(g_config.ffr.dynamic);
200+
if (g_config.ffr.dynamic) {
201+
LOG_INFO << " * Target FPS: " << std::setprecision(6) << (1.f / g_config.ffr.targetFrameTime);
202+
LOG_INFO << " * Target FT: " << std::setprecision(6) << (g_config.ffr.targetFrameTime * 1000.f) << "ms";
203+
LOG_INFO << " * Margin FPS: " << std::setprecision(6) << (1.f / g_config.ffr.marginFrameTime);
204+
LOG_INFO << " * Margin FT: " << std::setprecision(6) << (g_config.ffr.marginFrameTime * 1000.f) << "ms";
205+
LOG_INFO << " * Change radius is " << PrintToggle(g_config.ffr.dynamicChangeRadius);
206+
if (g_config.ffr.dynamicChangeRadius) {
207+
LOG_INFO << " * Min radius: " << std::setprecision(6) << g_config.ffr.minRadius;
208+
LOG_INFO << " * Inc radius: " << std::setprecision(6) << g_config.ffr.increaseRadiusStep;
209+
LOG_INFO << " * Dec radius: " << std::setprecision(6) << g_config.ffr.decreaseRadiusStep;
210+
}
211+
}
212+
} else {
213+
g_config.ffr.dynamic = false;
214+
}
215+
LOG_INFO << " Hidden radial mask is " << PrintToggle(g_config.hiddenMask.enabled);
216+
if (g_config.hiddenMask.enabled) {
217+
LOG_INFO << " * Radius: " << std::setprecision(6) << g_config.hiddenMask.radius;
218+
LOG_INFO << " * Precise res: " << PrintToggle(g_config.hiddenMask.preciseResolution);
219+
LOG_INFO << " * No renders: " << std::setprecision(6) << g_config.hiddenMask.ignoreFirstTargetRenders;
220+
LOG_INFO << " * Dynamic: " << PrintToggle(g_config.hiddenMask.dynamic);
221+
if (g_config.hiddenMask.dynamic) {
222+
LOG_INFO << " * Target FPS: " << std::setprecision(6) << (1.f / g_config.hiddenMask.targetFrameTime);
223+
LOG_INFO << " * Target FT: " << std::setprecision(6) << (g_config.hiddenMask.targetFrameTime * 1000.f) << "ms";
224+
LOG_INFO << " * Margin FPS: " << std::setprecision(6) << (1.f / g_config.hiddenMask.marginFrameTime);
225+
LOG_INFO << " * Margin FT: " << std::setprecision(6) << (g_config.hiddenMask.marginFrameTime * 1000.f) << "ms";
226+
LOG_INFO << " * Change radius is " << PrintToggle(g_config.hiddenMask.dynamicChangeRadius);
227+
if (g_config.hiddenMask.dynamicChangeRadius) {
228+
LOG_INFO << " - Min radius: " << std::setprecision(6) << g_config.hiddenMask.minRadius;
229+
LOG_INFO << " - Inc radius: " << std::setprecision(6) << g_config.hiddenMask.increaseRadiusStep;
230+
LOG_INFO << " - Dec radius: " << std::setprecision(6) << g_config.hiddenMask.decreaseRadiusStep;
231+
}
124232
}
233+
} else {
234+
g_config.hiddenMask.dynamic = false;
125235
}
126236
LOG_INFO << " Debug mode is " << PrintToggle(g_config.debugMode);
127237
FlushLog();

‎src/config.h‎

Lines changed: 39 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,9 @@ namespace vrperfkit {
77
struct UpscaleConfig {
88
bool enabled = false;
99
UpscaleMethod method = UpscaleMethod::NIS;
10-
float renderScale = 0.866f;
11-
float sharpness = 0.20f;
12-
float radius = 1.00f;
10+
float renderScale = 0.83667f;
11+
float sharpness = 0.30f;
12+
float radius = 0.95f;
1313
bool applyMipBias = true;
1414
};
1515

@@ -24,20 +24,53 @@ namespace vrperfkit {
2424

2525
struct FixedFoveatedConfig {
2626
bool enabled = false;
27+
bool apply = false;
2728
FixedFoveatedMethod method = FixedFoveatedMethod::VRS;
28-
float innerRadius = 0.70f;
29-
float midRadius = 0.85f;
30-
float outerRadius = 1.00f;
29+
float innerRadius = 0.50f;
30+
float midRadius = 0.65f;
31+
float outerRadius = 0.80f;
3132
bool favorHorizontal = true;
3233
std::string overrideSingleEyeOrder;
34+
bool fastMode = false;
35+
bool dynamic = false;
36+
bool dynamicChangeRadius = false;
37+
float targetFrameTime = 0.0167f;
38+
float marginFrameTime = 0.f;
39+
float minRadius = 0.30f;
40+
float maxRadius = 1.15f;
41+
float decreaseRadiusStep = 0.01f;
42+
float increaseRadiusStep = 0.03f;
43+
bool preciseResolution = true;
44+
int ignoreFirstTargetRenders = 0;
45+
bool radiusChanged[2] = { true, true };
46+
};
47+
48+
struct HiddenRadialMask {
49+
bool enabled = false;
50+
float radius = 1.15f;
51+
bool dynamic = false;
52+
bool dynamicChangeRadius = false;
53+
float targetFrameTime = 0.0167f;
54+
float marginFrameTime = 0.f;
55+
float minRadius = 0.8f;
56+
float maxRadius = 1.15f;
57+
float decreaseRadiusStep = 0.01f;
58+
float increaseRadiusStep = 0.03f;
59+
bool preciseResolution = true;
60+
int ignoreFirstTargetRenders = 0;
3361
};
3462

3563
struct Config {
3664
UpscaleConfig upscaling;
3765
DxvkConfig dxvk;
66+
GameMode gameMode = GameMode::AUTO;
67+
bool renderingSecondEye = false;
68+
int ffrDepthClearCount = 0;
3869
FixedFoveatedConfig ffr;
70+
HiddenRadialMask hiddenMask;
3971
bool debugMode = false;
4072
std::string dllLoadPath = "";
73+
int dynamicFramesCheck = 1;
4174
};
4275

4376
extern Config g_config;

0 commit comments

Comments
 (0)