Skip to content

Commit 6a71511

Browse files
RavenSystemRavenSystem
committed
Version 3.0
1 parent c0f705b commit 6a71511

16 files changed

Lines changed: 538 additions & 89 deletions

‎README.md‎

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

4+
[![Donate](https://img.shields.io/badge/donate-PayPal-blue.svg)](https://paypal.me/ravensystem)
5+
46
In an effort to continue this project, I have created this fork with updated components and SDKs. I added too some
57
improvements, like HRM and dynamic modes, and other compatibility options.
68

@@ -12,11 +14,15 @@ Included mods:
1214
* AMD FidelityFX Super Resolution
1315
* NVIDIA Image Scaling
1416
* AMD Contrast Adaptive Sharpening
15-
* FFR: Fixed foveated rendering (render center of image at full resolution, but drop resolution towards edges)
16-
* Variable Rate Shading (only for NVIDIA RTX / GTX 16xx cards)
17+
* FFR: Fixed foveated rendering: render center of image at full resolution, but drop resolution towards edges
18+
* VRS: Variable Rate Shading (only for NVIDIA RTX / GTX 16xx cards)
19+
* RDM: Radial Density Mask (all GPUs)
1720
* HRM: Hidden radial mask: don't render pixels at the edges that are not visible in the headset.
1821
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.
22+
* Dynamic modes for FFR and HRM based on FPS:
23+
* Apply only when needed.
24+
* Change the radius dinamically.
25+
* Several extra compatibility options to work with more games.
2026

2127
Supported VR runtimes:
2228

‎src/config.cpp‎

Lines changed: 60 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -32,13 +32,18 @@ namespace vrperfkit {
3232
case UpscaleMethod::CAS:
3333
return "CAS";
3434
}
35+
36+
return "Unknown";
3537
}
3638

3739
FixedFoveatedMethod FFRMethodFromString(std::string s) {
3840
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
3941
if (s == "vrs") {
4042
return FixedFoveatedMethod::VRS;
4143
}
44+
if (s == "rdm") {
45+
return FixedFoveatedMethod::RDM;
46+
}
4247
LOG_INFO << "Unknown fixed foveated method " << s << ", defaulting to VRS";
4348
return FixedFoveatedMethod::VRS;
4449
}
@@ -47,7 +52,11 @@ namespace vrperfkit {
4752
switch (method) {
4853
case FixedFoveatedMethod::VRS:
4954
return "VRS";
55+
case FixedFoveatedMethod::RDM:
56+
return "RDM";
5057
}
58+
59+
return "Unknown";
5160
}
5261

5362
GameMode GameModeFromString(std::string s) {
@@ -79,6 +88,8 @@ namespace vrperfkit {
7988
case GameMode::RIGHT_EYE_FIRST:
8089
return "right";
8190
}
91+
92+
return "Unknown";
8293
}
8394

8495
std::string PrintToggle(bool toggle) {
@@ -122,15 +133,22 @@ namespace vrperfkit {
122133
FixedFoveatedConfig &ffr = g_config.ffr;
123134
ffr.enabled = ffrCfg["enabled"].as<bool>(ffr.enabled);
124135
ffr.apply = ffr.enabled;
136+
ffr.method = FFRMethodFromString(ffrCfg["method"].as<std::string>(FFRMethodToString(ffr.method)));
125137
ffr.favorHorizontal = ffrCfg["favorHorizontal"].as<bool>(ffr.favorHorizontal);
126138
ffr.innerRadius = ffrCfg["innerRadius"].as<float>(ffr.innerRadius);
127139
ffr.midRadius = ffrCfg["midRadius"].as<float>(ffr.midRadius);
128140
ffr.outerRadius = ffrCfg["outerRadius"].as<float>(ffr.outerRadius);
141+
ffr.edgeRadius = ffrCfg["edgeRadius"].as<float>(ffr.edgeRadius);
129142
ffr.preciseResolution = ffrCfg["preciseResolution"].as<bool>(ffr.preciseResolution);
130143
ffr.ignoreFirstTargetRenders = ffrCfg["ignoreFirstTargetRenders"].as<int>(ffr.ignoreFirstTargetRenders);
144+
ffr.ignoreLastTargetRenders = ffrCfg["ignoreLastTargetRenders"].as<int>(ffr.ignoreLastTargetRenders);
131145
ffr.maxRadius = ffr.innerRadius;
132146
ffr.overrideSingleEyeOrder = ffrCfg["overrideSingleEyeOrder"].as<std::string>(ffr.overrideSingleEyeOrder);
133147
ffr.fastMode = ffrCfg["fastMode"].as<bool>(ffr.fastMode);
148+
g_config.ffrFastModeUsesHRMCount = ffrCfg["fastModeUsesHRMCount"].as<bool>(g_config.ffrFastModeUsesHRMCount);
149+
if (!ffr.fastMode) {
150+
g_config.ffrFastModeUsesHRMCount = false;
151+
}
134152
ffr.dynamic = ffrCfg["dynamic"].as<bool>(ffr.dynamic);
135153
ffr.targetFrameTime = 1.f / ffrCfg["targetFPS"].as<float>(ffr.targetFrameTime);
136154
ffr.marginFrameTime = 1.f / ffrCfg["marginFPS"].as<float>(ffr.marginFrameTime);
@@ -142,10 +160,11 @@ namespace vrperfkit {
142160
YAML::Node hiddenMaskCfg = cfg["hiddenMask"];
143161
HiddenRadialMask &hiddenMask= g_config.hiddenMask;
144162
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;
163+
hiddenMask.edgeRadius = std::max(0.f, hiddenMaskCfg["edgeRadius"].as<float>(hiddenMask.edgeRadius));
164+
hiddenMask.maxRadius = hiddenMask.edgeRadius;
147165
hiddenMask.preciseResolution = hiddenMaskCfg["preciseResolution"].as<bool>(hiddenMask.preciseResolution);
148166
hiddenMask.ignoreFirstTargetRenders = hiddenMaskCfg["ignoreFirstTargetRenders"].as<int>(hiddenMask.ignoreFirstTargetRenders);
167+
hiddenMask.ignoreLastTargetRenders = hiddenMaskCfg["ignoreLastTargetRenders"].as<int>(hiddenMask.ignoreLastTargetRenders);
149168
hiddenMask.dynamic = hiddenMaskCfg["dynamic"].as<bool>(hiddenMask.dynamic);
150169
hiddenMask.targetFrameTime = 1.f / hiddenMaskCfg["targetFPS"].as<float>(hiddenMask.targetFrameTime);
151170
hiddenMask.marginFrameTime = 1.f / hiddenMaskCfg["marginFPS"].as<float>(hiddenMask.marginFrameTime);
@@ -163,6 +182,31 @@ namespace vrperfkit {
163182
if (g_config.dynamicFramesCheck < 1) {
164183
g_config.dynamicFramesCheck = 1;
165184
}
185+
186+
if (g_config.ffr.enabled) {
187+
if (g_config.ffr.method == FixedFoveatedMethod::RDM) {
188+
g_config.ffr.fastMode = false;
189+
g_config.ffrFastModeUsesHRMCount = false;
190+
g_config.hiddenMask.enabled = false;
191+
192+
if (!g_config.upscaling.enabled) {
193+
g_config.upscaling.enabled = true;
194+
g_config.upscaling.radius = g_config.ffr.edgeRadius;
195+
g_config.upscaling.method = UpscaleMethod::CAS;
196+
g_config.upscaling.renderScale = 1.0f;
197+
g_config.upscaling.sharpness = 0.7f;
198+
g_config.upscaling.applyMipBias = false;
199+
}
200+
201+
} else if (g_config.ffr.method == FixedFoveatedMethod::VRS && !g_config.hiddenMask.enabled && g_config.ffrFastModeUsesHRMCount) {
202+
g_config.hiddenMask.enabled = true;
203+
g_config.hiddenMask.dynamic = false;
204+
g_config.hiddenMask.edgeRadius = 1.15f;
205+
g_config.hiddenMask.ignoreFirstTargetRenders = 0;
206+
g_config.hiddenMask.ignoreLastTargetRenders = 0;
207+
g_config.hiddenMask.preciseResolution = true;
208+
}
209+
}
166210
}
167211
catch (const YAML::Exception &e) {
168212
LOG_ERROR << "Failed to load configuration file: " << e.msg;
@@ -190,12 +234,18 @@ namespace vrperfkit {
190234
LOG_INFO << " * Inner radius: " << std::setprecision(6) << g_config.ffr.innerRadius;
191235
LOG_INFO << " * Mid radius: " << std::setprecision(6) << g_config.ffr.midRadius;
192236
LOG_INFO << " * Outer radius: " << std::setprecision(6) << g_config.ffr.outerRadius;
237+
if (g_config.ffr.method == FixedFoveatedMethod::RDM) {
238+
LOG_INFO << " * Edge radius: " << std::setprecision(6) << g_config.ffr.edgeRadius;
239+
}
193240
LOG_INFO << " * Precise res: " << PrintToggle(g_config.ffr.preciseResolution);
194-
LOG_INFO << " * No renders: " << std::setprecision(6) << g_config.ffr.ignoreFirstTargetRenders;
195-
if (!g_config.ffr.overrideSingleEyeOrder.empty()) {
241+
LOG_INFO << " * No first rend: " << std::setprecision(6) << g_config.ffr.ignoreFirstTargetRenders;
242+
LOG_INFO << " * No last rend: " << std::setprecision(6) << g_config.ffr.ignoreLastTargetRenders;
243+
LOG_INFO << " * Fast mode: " << PrintToggle(g_config.ffr.fastMode);
244+
if (g_config.ffr.fastMode) {
245+
LOG_INFO << " * HRM counter: " << PrintToggle(g_config.ffrFastModeUsesHRMCount);
246+
} else if (!g_config.ffr.overrideSingleEyeOrder.empty()) {
196247
LOG_INFO << " * Eye order: " << g_config.ffr.overrideSingleEyeOrder;
197248
}
198-
LOG_INFO << " * Fast mode: " << PrintToggle(g_config.ffr.fastMode);
199249
LOG_INFO << " * Dynamic: " << PrintToggle(g_config.ffr.dynamic);
200250
if (g_config.ffr.dynamic) {
201251
LOG_INFO << " * Target FPS: " << std::setprecision(6) << (1.f / g_config.ffr.targetFrameTime);
@@ -211,12 +261,15 @@ namespace vrperfkit {
211261
}
212262
} else {
213263
g_config.ffr.dynamic = false;
264+
g_config.ffr.fastMode = false;
214265
}
266+
215267
LOG_INFO << " Hidden radial mask is " << PrintToggle(g_config.hiddenMask.enabled);
216268
if (g_config.hiddenMask.enabled) {
217-
LOG_INFO << " * Radius: " << std::setprecision(6) << g_config.hiddenMask.radius;
269+
LOG_INFO << " * Edge radius: " << std::setprecision(6) << g_config.hiddenMask.edgeRadius;
218270
LOG_INFO << " * Precise res: " << PrintToggle(g_config.hiddenMask.preciseResolution);
219-
LOG_INFO << " * No renders: " << std::setprecision(6) << g_config.hiddenMask.ignoreFirstTargetRenders;
271+
LOG_INFO << " * No first rend: " << std::setprecision(6) << g_config.hiddenMask.ignoreFirstTargetRenders;
272+
LOG_INFO << " * No last rend: " << std::setprecision(6) << g_config.hiddenMask.ignoreLastTargetRenders;
220273
LOG_INFO << " * Dynamic: " << PrintToggle(g_config.hiddenMask.dynamic);
221274
if (g_config.hiddenMask.dynamic) {
222275
LOG_INFO << " * Target FPS: " << std::setprecision(6) << (1.f / g_config.hiddenMask.targetFrameTime);

‎src/config.h‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@ namespace vrperfkit {
2929
float innerRadius = 0.50f;
3030
float midRadius = 0.65f;
3131
float outerRadius = 0.80f;
32+
float edgeRadius = 1.15f;
3233
bool favorHorizontal = true;
3334
std::string overrideSingleEyeOrder;
3435
bool fastMode = false;
@@ -42,12 +43,13 @@ namespace vrperfkit {
4243
float increaseRadiusStep = 0.03f;
4344
bool preciseResolution = true;
4445
int ignoreFirstTargetRenders = 0;
46+
int ignoreLastTargetRenders = 0;
4547
bool radiusChanged[2] = { true, true };
4648
};
4749

4850
struct HiddenRadialMask {
4951
bool enabled = false;
50-
float radius = 1.15f;
52+
float edgeRadius = 1.15f;
5153
bool dynamic = false;
5254
bool dynamicChangeRadius = false;
5355
float targetFrameTime = 0.0167f;
@@ -58,14 +60,18 @@ namespace vrperfkit {
5860
float increaseRadiusStep = 0.03f;
5961
bool preciseResolution = true;
6062
int ignoreFirstTargetRenders = 0;
63+
int ignoreLastTargetRenders = 0;
6164
};
6265

6366
struct Config {
6467
UpscaleConfig upscaling;
6568
DxvkConfig dxvk;
6669
GameMode gameMode = GameMode::AUTO;
6770
bool renderingSecondEye = false;
68-
int ffrDepthClearCount = 0;
71+
bool ffrFastModeUsesHRMCount = false;
72+
bool ffrApplyFastMode = true;
73+
int ffrRenderTargetCount = 0;
74+
int ffrRenderTargetCountMax = 0;
6975
FixedFoveatedConfig ffr;
7076
HiddenRadialMask hiddenMask;
7177
bool debugMode = false;

‎src/d3d11/d3d11_injector.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -102,28 +102,28 @@ namespace vrperfkit {
102102
context->SetPrivateData(__uuidof(D3D11Injector), size, &instance);
103103

104104
// Upscaling and FFR
105-
if (g_config.upscaling.enabled || g_config.ffr.enabled) {
105+
if (g_config.upscaling.enabled || (g_config.ffr.enabled && g_config.ffr.method == FixedFoveatedMethod::VRS)) {
106106
hooks::InstallVirtualFunctionHook("ID3D11DeviceContext::PSSetSamplers", context.Get(), 10, (void*)&D3D11ContextHook_PSSetSamplers);
107107
hooks::InstallVirtualFunctionHook("ID3D11DeviceContext::OMSetRenderTargets", context.Get(), 33, (void*)&D3D11ContextHook_OMSetRenderTargets);
108108
hooks::InstallVirtualFunctionHook("ID3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews", context.Get(), 34, (void*)&D3D11ContextHook_OMSetRenderTargetsAndUnorderedAccessViews);
109109
}
110110

111111
// HRM
112-
if (g_config.hiddenMask.enabled) {
112+
if (g_config.hiddenMask.enabled || (g_config.ffr.enabled && g_config.ffr.method == FixedFoveatedMethod::RDM)) {
113113
hooks::InstallVirtualFunctionHook("ID3D11DeviceContext::ClearDepthStencilView", context.Get(), 53, (void*)&D3D11ContextHook_ClearDepthStencilView);
114114
}
115115
}
116116

117117
D3D11Injector::~D3D11Injector() {
118118
// Upscaling && FFR
119-
if (g_config.upscaling.enabled || g_config.ffr.enabled) {
119+
if (g_config.upscaling.enabled || (g_config.ffr.enabled && g_config.ffr.method == FixedFoveatedMethod::VRS)) {
120120
hooks::RemoveHook((void*)&D3D11ContextHook_PSSetSamplers);
121121
hooks::RemoveHook((void*)&D3D11ContextHook_OMSetRenderTargets);
122122
hooks::RemoveHook((void*)&D3D11ContextHook_OMSetRenderTargetsAndUnorderedAccessViews);
123123
}
124124

125125
// HRM
126-
if (g_config.hiddenMask.enabled) {
126+
if (g_config.hiddenMask.enabled || (g_config.ffr.enabled && g_config.ffr.method == FixedFoveatedMethod::RDM)) {
127127
hooks::RemoveHook((void*)&D3D11ContextHook_ClearDepthStencilView);
128128
}
129129

0 commit comments

Comments
 (0)