feat(fromsoft, resource): Rework tonemap and create AreCopyFormatsCompatible in resource.hpp

src/games/fromsoft_engine/addon.cpp

@@ -4,7 +4,8 @@
  */
 
 #include <cstddef>
-#define ImTextureID ImU64
+#define ImTextureID                   ImU64
+#define RENODX_MODS_SWAPCHAIN_VERSION 2
 
 #define DEBUG_LEVEL_0
 
@@ -81,7 +82,7 @@ renodx::utils::settings::Settings settings = {
         .label = "Tone Mapper",
         .section = "Tone Mapping",
         .tooltip = "Sets the tone mapper type",
-        .labels = {"Vanilla", "RenoDRT"},
+        .labels = {"Vanilla", "Neutwo", "PsychoV"},
         .parse = [](float value) { return value * 3.f; },
         .is_visible = []() { return current_settings_mode >= 1; },
     }),
@@ -116,6 +117,39 @@ renodx::utils::settings::Settings settings = {
         .min = 48.f,
         .max = 500.f,
     },
+    new renodx::utils::settings::Setting{
+        .key = "UIVisibility",
+        .binding = &shader_injection.custom_ui_visibility,
+        .value_type = renodx::utils::settings::SettingValueType::BOOLEAN,
+        .default_value = 1.f,
+        .label = "UI Visibility",
+        .section = "Tone Mapping",
+        .labels = {"Hide", "Show"},
+        .is_enabled = []() { return shader_injection.tone_map_type != 0; },
+    },
+    new renodx::utils::settings::Setting{
+        .key = "ToneMapScaling",
+        .binding = &shader_injection.tone_map_per_channel,
+        .value_type = renodx::utils::settings::SettingValueType::INTEGER,
+        .default_value = 1.f,
+        .label = "Scaling",
+        .section = "Tone Mapping",
+        .tooltip = "Luminosity scales colors consistently",
+        .labels = {"Luminance", "Per Channel"},
+        .is_enabled = []() { return shader_injection.tone_map_type > 0; },
+        .is_visible = []() { return current_settings_mode >= 1; },
+    },
+    new renodx::utils::settings::Setting{
+        .key = "ToneMapHueEmulationMethod",
+        .binding = &shader_injection.tone_map_hue_emulation_method,
+        .value_type = renodx::utils::settings::SettingValueType::INTEGER,
+        .default_value = 3.f,
+        .label = "Hue Emulation Method",
+        .section = "Tone Mapping",
+        .tooltip = "Applies hue emulation after tonemapping",
+        .labels = {"LMS (Off)", "Untonemapped", "BT.709", "BT.2020"},
+        .is_visible = []() { return current_settings_mode >= 1 && shader_injection.tone_map_type == 6.f; },
+    },
     new renodx::utils::settings::Setting{
         .key = "ColorGradeExposure",
         .binding = &shader_injection.tone_map_exposure,
@@ -130,7 +164,7 @@ renodx::utils::settings::Settings settings = {
     CreateDefault50PercentSetting({
         .key = "ColorGradeHighlights",
         .binding = &shader_injection.tone_map_highlights,
-        .default_value = 52.f,
+        .default_value = 50.f,
         .label = "Highlights",
         .section = "Color Grading",
         .is_enabled = []() { return shader_injection.tone_map_type > 0; },
@@ -163,7 +197,7 @@ renodx::utils::settings::Settings settings = {
     CreateDefault50PercentSetting({
         .key = "ColorGradeHighlightSaturation",
         .binding = &shader_injection.tone_map_highlight_saturation,
-        .default_value = 55.f,
+        .default_value = 50.f,
         .label = "Highlight Saturation",
         .section = "Color Grading",
         .is_enabled = []() { return shader_injection.tone_map_type > 0; },
@@ -188,6 +222,40 @@ renodx::utils::settings::Settings settings = {
         .parse = [](float value) { return value * 0.01f; },
         .is_visible = []() { return current_settings_mode >= 1; },
     },
+    new renodx::utils::settings::Setting{
+        .key = "ColorGradeStrength",
+        .binding = &shader_injection.custom_lut_strength,
+        .default_value = 100.f,
+        .label = "Color Grade Strength",
+        .section = "Color Grading",
+        .max = 100.f,
+        .is_enabled = []() { return shader_injection.tone_map_type > 0; },
+        .parse = [](float value) { return value * 0.01f; },
+        .is_visible = []() { return current_settings_mode >= 2; },
+    },
+    new renodx::utils::settings::Setting{
+        .key = "ColorGradeLUTScaling",
+        .binding = &shader_injection.custom_lut_scaling,
+        .default_value = 100.f,
+        .label = "LUT Scaling",
+        .section = "Color Grading",
+        .tooltip = "Scales the color grade LUT to full range when size is clamped.",
+        .max = 100.f,
+        .is_enabled = []() { return shader_injection.tone_map_type > 0; },
+        .parse = [](float value) { return value * 0.01f; },
+        .is_visible = []() { return current_settings_mode >= 2; },
+    },
+    new renodx::utils::settings::Setting{
+        .key = "ColorGradeLUTGamutRestoration",
+        .binding = &shader_injection.custom_lut_gamut_restoration,
+        .value_type = renodx::utils::settings::SettingValueType::BOOLEAN,
+        .default_value = 1.f,
+        .label = "LUT Gamut Restoration",
+        .section = "Color Grading",
+        .tooltip = "Restores wide gamut colors clipped by the LUT",
+        .is_enabled = []() { return shader_injection.tone_map_type != 0; },
+        .is_visible = []() { return current_settings_mode >= 2; },
+    },
     renodx::templates::settings::CreateSetting({
         .key = "FxPostProcessCA",
         .binding = &shader_injection.custom_fx_chromatic_aberration,
@@ -313,7 +381,9 @@ void OnPresetOff() {
       {"ToneMapPeakNits", 203.f},
       {"ToneMapGameNits", 203.f},
       {"ToneMapUINits", 203.f},
+      {"UIVisibility", 1.f},
       {"ToneMapGammaCorrection", 0.f},
+      {"ToneMapScaling", 1.f},
       {"ColorGradeExposure", 1.f},
       {"ColorGradeHighlights", 50.f},
       {"ColorGradeShadows", 50.f},
@@ -322,7 +392,10 @@ void OnPresetOff() {
       {"ColorGradeHighlightSaturation", 50.f},
       {"ColorGradeBlowout", 0.f},
       {"ColorGradeFlare", 0.f},
-      {"FxPostProcessCA", 0.f},
+      {"ColorGradeStrength", 100.f},
+      {"ColorGradeLUTScaling", 0.f},
+      {"ColorGradeLUTGamutRestoration", 0.f},
+      {"FxPostProcessCA", 1.f},
       {"FxGrainType", 0.f},
       {"FxGrainStrength", 50.f},
       {"ColorGradeColorSpace", 0.f},  // US CRT
@@ -347,6 +420,30 @@ void OnInitSwapchain(reshade::api::swapchain* swapchain, bool resize) {
   fired_on_init_swapchain = true;
 }
 
+void OnInitDevice(reshade::api::device* device) {
+  std::vector<renodx::utils::resource::ResourceUpgradeInfo> upgrade_infos = {};
+
+  int vendor_id;
+  auto retrieved = device->get_property(reshade::api::device_properties::vendor_id, &vendor_id);
+  if (retrieved) {
+    if (vendor_id == 0x10de) {  // rgba16 for NVIDIA
+      upgrade_infos.push_back({
+          .old_format = reshade::api::format::r11g11b10_float,
+          .new_format = reshade::api::format::r16g16b16a16_float,
+          .aspect_ratio = renodx::mods::swapchain::SwapChainUpgradeTarget::BACK_BUFFER,
+      });
+    } else if (vendor_id == 0x1002) {  // rgb9e5 for AMD
+      upgrade_infos.push_back({
+          .old_format = reshade::api::format::r11g11b10_float,
+          .new_format = reshade::api::format::r9g9b9e5,
+          .aspect_ratio = renodx::mods::swapchain::SwapChainUpgradeTarget::BACK_BUFFER,
+      });
+    }
+  }
+
+  renodx::utils::resource::upgrade::SetUpgradeInfos(device, upgrade_infos);
+}
+
 bool initialized = false;
 
 }  // namespace
@@ -358,7 +455,7 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) {
   switch (fdw_reason) {
     case DLL_PROCESS_ATTACH:
       if (!reshade::register_addon(h_module)) return FALSE;
-      reshade::register_event<reshade::addon_event::init_swapchain>(OnInitSwapchain);
+      renodx::utils::resource::upgrade::Use(fdw_reason);  // fp11 upgrades
 
       /* renodx::mods::shader::on_create_pipeline_layout = [](auto, auto params) {
         if (params.size() >= 8) return false;
@@ -378,27 +475,33 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) {
         renodx::mods::swapchain::use_resource_cloning = true;
         renodx::mods::swapchain::SetUseHDR10();
 
-        /* renodx::mods::swapchain::swap_chain_upgrade_targets.push_back({
-            .old_format = reshade::api::format::r11g11b10_float,
-            .new_format = reshade::api::format::r16g16b16a16_float,
-            .use_resource_view_cloning = true
-        }); */
-
         renodx::utils::random::binds.push_back(&shader_injection.custom_random);
         initialized = true;
       }
 
+      reshade::register_event<reshade::addon_event::init_device>(OnInitDevice);  // fp11 upgrades
+      reshade::register_event<reshade::addon_event::init_swapchain>(OnInitSwapchain);
+
       break;
     case DLL_PROCESS_DETACH:
-      reshade::unregister_addon(h_module);
+      renodx::utils::resource::upgrade::Use(fdw_reason);  // fp11 upgrades
+
+      reshade::unregister_event<reshade::addon_event::init_device>(OnInitDevice);  // fp11 upgrades
       reshade::unregister_event<reshade::addon_event::init_swapchain>(OnInitSwapchain);
 
+      reshade::unregister_addon(h_module);
       break;
   }
 
   renodx::utils::settings::Use(fdw_reason, &settings, &OnPresetOff);
-  // renodx::mods::swapchain::Use(fdw_reason, &shader_injection);
+
+  if (fdw_reason == DLL_PROCESS_ATTACH) {  // ALways reset UI visibility to on
+    renodx::utils::settings::UpdateSetting("UIVisibility", 1.f);
+  }
+
+  renodx::mods::swapchain::Use(fdw_reason);
   renodx::mods::shader::Use(fdw_reason, custom_shaders, &shader_injection);
+  renodx::utils::random::Use(fdw_reason);
 
   return TRUE;
 }

src/games/fromsoft_engine/armoredcore6/final_0x21706BCF.ps_6_0.hlsl

@@ -32,13 +32,13 @@ float4 main(
   linear float2 TEXCOORD_1 : TEXCOORD1
 ) : SV_Target {
   float4 SV_Target;
-  float4 _16 = HDRScene.Sample(LinearClampSampler, float2((g_HDRTexturePercentage.x * TEXCOORD_1.x), (g_HDRTexturePercentage.y * TEXCOORD_1.y)));
-  float4 _25 = UIScene.Sample(LinearClampSampler, float2((g_UITexturePercentage.x * TEXCOORD_1.x), (g_UITexturePercentage.y * TEXCOORD_1.y)));
-
-  if (HandleFinal(_16, _25, SV_Target, SV_Position)) {
+  if (HandleFinal(float4(HDRScene.Sample(LinearClampSampler, TEXCOORD_1.xy).xyz, 1.f), UIScene.Sample(LinearClampSampler, TEXCOORD_1.xy).xyzw, SV_Target, SV_Position)) {
     return SV_Target;
   }
 
+  float4 _16 = HDRScene.Sample(LinearClampSampler, float2((g_HDRTexturePercentage.x * TEXCOORD_1.x), (g_HDRTexturePercentage.y * TEXCOORD_1.y)));
+  float4 _25 = UIScene.Sample(LinearClampSampler, float2((g_UITexturePercentage.x * TEXCOORD_1.x), (g_UITexturePercentage.y * TEXCOORD_1.y)));
+
   float _44 = exp2(log2(_16.x * 2.009232997894287f) * 1.5f);
   float _45 = exp2(log2(_16.y * 2.009232997894287f) * 1.5f);
   float _46 = exp2(log2(_16.z * 2.009232997894287f) * 1.5f);

src/games/fromsoft_engine/armoredcore6/final_0x6557F4B9.ps_6_0.hlsl

@@ -26,13 +26,13 @@ float4 main(
     linear float4 TEXCOORD: TEXCOORD,
     linear float2 TEXCOORD_1: TEXCOORD1) : SV_Target {
   float4 SV_Target;
-  float4 _10 = HDRScene.Sample(LinearClampSampler, float2(TEXCOORD_1.x, TEXCOORD_1.y));
-  float4 _14 = UIScene.Sample(LinearClampSampler, float2(TEXCOORD_1.x, TEXCOORD_1.y));
-
-  if (HandleFinal(_10, _14, SV_Target, SV_Position)) {
+  if (HandleFinal(float4(HDRScene.Sample(LinearClampSampler, TEXCOORD_1.xy).xyz, 1.f), UIScene.Sample(LinearClampSampler, TEXCOORD_1.xy).xyzw, SV_Target, SV_Position)) {
     return SV_Target;
   }
 
+  float4 _10 = HDRScene.Sample(LinearClampSampler, float2(TEXCOORD_1.x, TEXCOORD_1.y));
+  float4 _14 = UIScene.Sample(LinearClampSampler, float2(TEXCOORD_1.x, TEXCOORD_1.y));
+
   float _33 = exp2(log2(_10.x * 2.009232997894287f) * 1.5f);
   float _34 = exp2(log2(_10.y * 2.009232997894287f) * 1.5f);
   float _35 = exp2(log2(_10.z * 2.009232997894287f) * 1.5f);

src/games/fromsoft_engine/armoredcore6/tonemapper_0x74971D15.ps_6_0.hlsl

@@ -65,24 +65,15 @@ float4 main(
 
   float3 untonemapped = float3(_65, _66, _67);
 
-  if (CUSTOM_MATCH_MIDGRAY) {
-    float y_in = renodx::color::y::from::NTSC1953(untonemapped);
-    float y_out = g_ToneMapTableTexture.SampleLevel(SS_ClampLinear, float2((((y_in / (y_in + 0.20000000298023224f)) * 0.9990234375f) + 0.00048828125f), 0.0f), 0.0f).r;
-    const float midgray = 0.18f;
-    float midgray_lum = g_ToneMapTableTexture.SampleLevel(SS_ClampLinear, float2((((midgray / (midgray + 0.20000000298023224f)) * 0.9990234375f) + 0.00048828125f), 0.0f), 0.0f).r;
-
-    float3 luminance_tonemapped = untonemapped * (y_out / y_in);
-    untonemapped = untonemapped * (midgray_lum / midgray);
-    untonemapped = lerp(luminance_tonemapped, untonemapped, saturate(luminance_tonemapped));
-  }
-
-  float3 sdr_tonemapped;
-  if (!ApplyLuminanceSaturationAdjustments(untonemapped, sdr_tonemapped)) {
+  float3 tonemapped;
+  if (RENODX_TONE_MAP_TYPE == 0.f) {
     float4 _74 = g_ToneMapTableTexture.SampleLevel(SS_ClampLinear, float2((_65 / (_65 + 0.20000000298023224f)), 0.0f), 0.0f);
     float4 _76 = g_ToneMapTableTexture.SampleLevel(SS_ClampLinear, float2((_66 / (_66 + 0.20000000298023224f)), 0.0f), 0.0f);
     float4 _78 = g_ToneMapTableTexture.SampleLevel(SS_ClampLinear, float2((_67 / (_67 + 0.20000000298023224f)), 0.0f), 0.0f);
 
-    sdr_tonemapped = float3(_74.x, _76.x, _78.x);
+    tonemapped = float3(_74.x, _76.x, _78.x);
+  } else {
+    tonemapped = ApplyFromSoftToneMapExtended(untonemapped, g_ReinhardParam, g_ToneMapParam);
   }
 
   float _89 = g_vVignettingParam.x * ((TEXCOORD.x * 2.0f) + -1.0f);
@@ -93,36 +84,37 @@ float4 main(
   float _103 = _102 * _102;
 
   const float vanilla_gamma = 1 / g_ToneMapParam.z;
+  tonemapped = _103 * tonemapped;
+
+  float4 _130 = g_ColorGradingLUTTexture.Sample(
+      SS_ClampLinear,
+      (exp2(log2(max(tonemapped, 0.0f)) * g_ToneMapParam.z) * 0.9375f) + 0.03125f);
 
-  float4 _130 = g_ColorGradingLUTTexture.Sample(SS_ClampLinear, float3(((exp2(log2(max((_103 * sdr_tonemapped.r), 0.0f)) * g_ToneMapParam.z) * 0.9375f) + 0.03125f), ((exp2(log2(max((_103 * sdr_tonemapped.g), 0.0f)) * g_ToneMapParam.z) * 0.9375f) + 0.03125f), ((exp2(log2(max((_103 * sdr_tonemapped.b), 0.0f)) * g_ToneMapParam.z) * 0.9375f) + 0.03125f)));
   bool isHDR = !(g_bEnableFlags.z == 0);
-  // Menus blend game and UI sometimes, so it has to be gamma encoded
-  // wanted to avoid avoid inner branching so we just return original lut sampling
-  if (RENODX_TONE_MAP_TYPE && isHDR) {
-    _130.rgb = SampleLUT((sdr_tonemapped * _103), g_ColorGradingLUTTexture, SS_ClampLinear);
-  }
+
   float _214;
   float _215;
   float _216;
   [branch]
   if (isHDR) {
-    if (Tonemap(untonemapped, _130, SV_Target, TEXCOORD)) {
+    if (ApplyLUTAndToneMapAndRenderIntermediatePass(tonemapped, g_ColorGradingLUTTexture, SS_ClampLinear, SV_Target,
+                                                    float3(g_dynamicScreenPercentage * TEXCOORD.xy, 1.f), g_ToneMapInvSceneLumScale,
+                                                    g_ReinhardParam, g_ToneMapParam, g_vHDRDisplayParam)) {
       return SV_Target;
-    } else {
-      float _135 = 1.0f / g_ToneMapParam.z;
-      float _145 = exp2(log2(max(_130.x, 0.0f)) * _135);
-      float _146 = exp2(log2(max(_130.y, 0.0f)) * _135);
-      float _147 = exp2(log2(max(_130.z, 0.0f)) * _135);
-      float _159 = 1.0f / g_ReinhardParam.x;
-      float _169 = dot(float3(exp2(log2(_145 / max((1.0f - _145), 0.009999999776482582f)) * _159), exp2(log2(_146 / max((1.0f - _146), 0.009999999776482582f)) * _159), exp2(log2(_147 / max((1.0f - _147), 0.009999999776482582f)) * _159)), float3(0.298909991979599f, 0.5866100192070007f, 0.11448000371456146f));
-      float _172 = (pow(_169, g_ReinhardParam.x));
-      float _180 = exp2(log2(((_169 + -1.0f) * 0.05263157933950424f) + 1.0f) * g_ReinhardParam.x);
-      float _187 = select((_169 > 1.0f), ((((_180 / (_180 + 1.0f)) + -0.5f) * 19.0f) + 0.5f), (_172 / (_172 + 1.0f)));
-      float _192 = dot(float3(_145, _146, _147), float3(0.298909991979599f, 0.5866100192070007f, 0.11448000371456146f)) + 9.999999747378752e-05f;
-      _214 = (exp2(log2(g_vHDRDisplayParam.y * ((_187 * _145) / _192)) * 0.3030303120613098f) * 0.49770236015319824f);
-      _215 = (exp2(log2(g_vHDRDisplayParam.y * ((_187 * _146) / _192)) * 0.3030303120613098f) * 0.49770236015319824f);
-      _216 = (exp2(log2(g_vHDRDisplayParam.y * ((_187 * _147) / _192)) * 0.3030303120613098f) * 0.49770236015319824f);
     }
+    float _135 = 1.0f / g_ToneMapParam.z;
+    float _145 = exp2(log2(max(_130.x, 0.0f)) * _135);
+    float _146 = exp2(log2(max(_130.y, 0.0f)) * _135);
+    float _147 = exp2(log2(max(_130.z, 0.0f)) * _135);
+    float _159 = 1.0f / g_ReinhardParam.x;
+    float _169 = dot(float3(exp2(log2(_145 / max((1.0f - _145), 0.009999999776482582f)) * _159), exp2(log2(_146 / max((1.0f - _146), 0.009999999776482582f)) * _159), exp2(log2(_147 / max((1.0f - _147), 0.009999999776482582f)) * _159)), float3(0.298909991979599f, 0.5866100192070007f, 0.11448000371456146f));
+    float _172 = (pow(_169, g_ReinhardParam.x));
+    float _180 = exp2(log2(((_169 + -1.0f) * 0.05263157933950424f) + 1.0f) * g_ReinhardParam.x);
+    float _187 = select((_169 > 1.0f), ((((_180 / (_180 + 1.0f)) + -0.5f) * 19.0f) + 0.5f), (_172 / (_172 + 1.0f)));
+    float _192 = dot(float3(_145, _146, _147), float3(0.298909991979599f, 0.5866100192070007f, 0.11448000371456146f)) + 9.999999747378752e-05f;
+    _214 = (exp2(log2(g_vHDRDisplayParam.y * ((_187 * _145) / _192)) * 0.3030303120613098f) * 0.49770236015319824f);
+    _215 = (exp2(log2(g_vHDRDisplayParam.y * ((_187 * _146) / _192)) * 0.3030303120613098f) * 0.49770236015319824f);
+    _216 = (exp2(log2(g_vHDRDisplayParam.y * ((_187 * _147) / _192)) * 0.3030303120613098f) * 0.49770236015319824f);
   } else {
     _214 = _130.x;
     _215 = _130.y;