Preliminary HDR patch

tssge · tssge · commit e86e2a25ea46 · 2025-05-22T15:55:10.000-11:00
Meaningful changes picked from doodlum#1019 Get rid of tonemapping code and settings I plan on letting DXVK or the compositor to handle proper PQ Set DXGI buffer types based on HDR option Move HDR state from ShaderCache to State Fix menu Fix warning Add more debugging info More fixes Fix fix style: 🎨 apply clang-format changes Try with 10bit backbuffers Fix Some format changes Attempt to apply PQ only once style: 🎨 apply clang-format changes Revert format change for upgrades Try again Not being ran Fix style: 🎨 apply clang-format changes Fix upscaling Some more fixes Try without frame generation
diff --git a/src/DX12SwapChain.cpp b/src/DX12SwapChain.cpp
@@ -187,7 +187,8 @@ WrappedResource::WrappedResource(D3D11_TEXTURE2D_DESC a_texDesc, ID3D11Device5*
 		flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
 	if (!(a_texDesc.BindFlags & D3D11_BIND_RENDER_TARGET))
 		flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
-	D3D12_RESOURCE_DESC desc12{ D3D12_RESOURCE_DIMENSION_TEXTURE2D, 0, a_texDesc.Width, a_texDesc.Height, (UINT16)a_texDesc.ArraySize, (UINT16)a_texDesc.MipLevels, a_texDesc.Format, { a_texDesc.SampleDesc.Count, a_texDesc.SampleDesc.Quality }, D3D12_TEXTURE_LAYOUT_UNKNOWN, flags };
+	D3D12_RESOURCE_DESC desc12{ D3D12_RESOURCE_DIMENSION_TEXTURE2D, 0, a_texDesc.Width, a_texDesc.Height, (UINT16)a_texDesc.ArraySize,
+		(UINT16)a_texDesc.MipLevels, a_texDesc.Format, { a_texDesc.SampleDesc.Count, a_texDesc.SampleDesc.Quality }, D3D12_TEXTURE_LAYOUT_UNKNOWN, flags };
 	D3D12_HEAP_PROPERTIES heapProp = { D3D12_HEAP_TYPE_DEFAULT, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_MEMORY_POOL_UNKNOWN, 1, 1 };
 
 	DX::ThrowIfFailed(a_d3d12Device->CreateCommittedResource(&heapProp, D3D12_HEAP_FLAG_SHARED, &desc12, D3D12_RESOURCE_STATE_COMMON, nullptr, IID_PPV_ARGS(&resource)));
diff --git a/src/Deferred.cpp b/src/Deferred.cpp
@@ -95,15 +95,15 @@ void Deferred::SetupResources()
 		// TEMPORAL_AA_WATER_2
 
 		// Albedo
-		SetupRenderTarget(ALBEDO, texDesc, srvDesc, rtvDesc, uavDesc, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+		SetupRenderTarget(ALBEDO, texDesc, srvDesc, rtvDesc, uavDesc, globals::state->UpgradeDxgiFormat(DXGI_FORMAT_R8G8B8A8_UNORM), D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
 		// Specular
-		SetupRenderTarget(SPECULAR, texDesc, srvDesc, rtvDesc, uavDesc, DXGI_FORMAT_R11G11B10_FLOAT, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+		SetupRenderTarget(SPECULAR, texDesc, srvDesc, rtvDesc, uavDesc, globals::state->UpgradeDxgiFormat(DXGI_FORMAT_R11G11B10_FLOAT), D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
 		// Reflectance
-		SetupRenderTarget(REFLECTANCE, texDesc, srvDesc, rtvDesc, uavDesc, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+		SetupRenderTarget(REFLECTANCE, texDesc, srvDesc, rtvDesc, uavDesc, globals::state->UpgradeDxgiFormat(DXGI_FORMAT_R8G8B8A8_UNORM), D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
 		// Normal + Roughness
-		SetupRenderTarget(NORMALROUGHNESS, texDesc, srvDesc, rtvDesc, uavDesc, DXGI_FORMAT_R10G10B10A2_UNORM, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+		SetupRenderTarget(NORMALROUGHNESS, texDesc, srvDesc, rtvDesc, uavDesc, globals::state->UpgradeDxgiFormat(DXGI_FORMAT_R10G10B10A2_UNORM), D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
 		// Masks
-		SetupRenderTarget(MASKS, texDesc, srvDesc, rtvDesc, uavDesc, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+		SetupRenderTarget(MASKS, texDesc, srvDesc, rtvDesc, uavDesc, globals::state->UpgradeDxgiFormat(DXGI_FORMAT_R8G8B8A8_UNORM), D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
 	}
 
 	{
diff --git a/src/Features/DynamicCubemaps.cpp b/src/Features/DynamicCubemaps.cpp
@@ -52,7 +52,7 @@ void DynamicCubemaps::DrawSettings()
 					auto context = globals::d3d::context;
 
 					D3D11_TEXTURE2D_DESC texDesc{};
-					texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+					texDesc.Format = globals::state->UpgradeDxgiFormat(DXGI_FORMAT_R8G8B8A8_UNORM);
 					texDesc.Height = 1;
 					texDesc.Width = 1;
 					texDesc.ArraySize = 6;
diff --git a/src/FidelityFX.cpp b/src/FidelityFX.cpp
@@ -178,6 +178,12 @@ void FidelityFX::CreateFSRResources()
 	contextDescription.flags = FFX_FSR3_ENABLE_UPSCALING_ONLY | FFX_FSR3_ENABLE_AUTO_EXPOSURE;
 	contextDescription.backBufferFormat = FFX_SURFACE_FORMAT_R8G8B8A8_UNORM;
 
+	if (globals::state->IsHdrRendering()) {
+		logger::info("[FidelityFX] Enabling HDR rendering");
+		contextDescription.flags |= FFX_FSR3_ENABLE_HIGH_DYNAMIC_RANGE;
+		contextDescription.backBufferFormat = FFX_SURFACE_FORMAT_R10G10B10A2_UNORM;
+	}
+
 	contextDescription.backendInterfaceUpscaling = fsrInterface;
 
 	if (ffxFsr3ContextCreate(&fsrContext, &contextDescription) != FFX_OK)
diff --git a/src/Hooks.cpp b/src/Hooks.cpp
@@ -360,6 +360,13 @@ HRESULT WINAPI hk_D3D11CreateDeviceAndSwapChain(
 		if (streamline->featureDLSSG) {
 			logger::info("[Frame Generation] Using D3D12 proxy via Streamline");
 
+			if (globals::state->IsHdrRendering()) {
+				logger::info("[Streamline] Enabling 10bit swapchain");
+				pSwapChainDesc->BufferDesc.Format = DXGI_FORMAT_R10G10B10A2_UNORM;
+				logger::info("[Streamline] Enabling BT.2020 ST2084 (PQ) HDR colorspace");
+				pSwapChainDesc->BufferDesc.ColorSpace = DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
+			}
+
 			auto ret = streamline->slD3D11CreateDeviceAndSwapChain(pAdapter,
 				DriverType,
 				Software,
@@ -434,6 +441,13 @@ HRESULT WINAPI hk_D3D11CreateDeviceAndSwapChain(
 		}
 	}
 
+	if (globals::state->IsHdrRendering()) {
+		logger::info("[Hooks] Enabling 10bit swapchain");
+		pSwapChainDesc->BufferDesc.Format = DXGI_FORMAT_R10G10B10A2_UNORM;
+		logger::info("[Hooks] Enabling HDR colorspace");
+		pSwapChainDesc->BufferDesc.ColorSpace = DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
+	}
+
 	auto ret = ptrD3D11CreateDeviceAndSwapChain(pAdapter,
 		DriverType,
 		Software,
@@ -447,7 +461,63 @@ HRESULT WINAPI hk_D3D11CreateDeviceAndSwapChain(
 		pFeatureLevel,
 		ppImmediateContext);
 
+	if (globals::state->IsHdrRendering()) {
+    	logger::info("[Hooks] Setting HDR metadata");
+    	IDXGISwapChain4* swapChain4 = nullptr;
+    	IDXGIOutput* output = nullptr;
+    	IDXGIOutput6* output6 = nullptr;
+    	DXGI_OUTPUT_DESC1 displayDesc = {};
+    	DXGI_HDR_METADATA_HDR10 metadata = {};
+
+        if (SUCCEEDED((*ppSwapChain)->QueryInterface(__uuidof(IDXGISwapChain4), (void**)&swapChain4))) {
+            swapChain4->GetContainingOutput(&output);
+    	    output->QueryInterface(IID_PPV_ARGS(&output6));
+    	    output6->GetDesc1(&displayDesc);
+
+    	    // Log color primaries
+    	    logger::info("Display Color Primaries:");
+    	    logger::info("Red   Primary: ({:.4f}, {:.4f})", displayDesc.RedPrimary[0], displayDesc.RedPrimary[1]);
+    	    logger::info("Green Primary: ({:.4f}, {:.4f})", displayDesc.GreenPrimary[0], displayDesc.GreenPrimary[1]);
+    	    logger::info("Blue  Primary: ({:.4f}, {:.4f})", displayDesc.BluePrimary[0], displayDesc.BluePrimary[1]);
+    	    logger::info("White Point:   ({:.4f}, {:.4f})", displayDesc.WhitePoint[0], displayDesc.WhitePoint[1]);
+
+    	    // Log luminance values
+    	    logger::info("Display Luminance Range:");
+    	    logger::info("Min Luminance: {:.2f} nits", displayDesc.MinLuminance);
+    	    logger::info("Max Luminance: {:.2f} nits", displayDesc.MaxLuminance);
+    		logger::info("MaxFullFrameLuminance: {:.2f} nits", displayDesc.MaxFullFrameLuminance);
+
+    	    // Convert display primaries (display values are 0-1, metadata needs them scaled by 50000)
+    	    metadata.RedPrimary[0] = static_cast<UINT16>(displayDesc.RedPrimary[0] * 50000);
+    	    metadata.RedPrimary[1] = static_cast<UINT16>(displayDesc.RedPrimary[1] * 50000);
+
+    	    metadata.GreenPrimary[0] = static_cast<UINT16>(displayDesc.GreenPrimary[0] * 50000);
+    	    metadata.GreenPrimary[1] = static_cast<UINT16>(displayDesc.GreenPrimary[1] * 50000);
+
+    	    metadata.BluePrimary[0] = static_cast<UINT16>(displayDesc.BluePrimary[0] * 50000);
+    	    metadata.BluePrimary[1] = static_cast<UINT16>(displayDesc.BluePrimary[1] * 50000);
+
+    	    metadata.WhitePoint[0] = static_cast<UINT16>(displayDesc.WhitePoint[0] * 50000);
+    	    metadata.WhitePoint[1] = static_cast<UINT16>(displayDesc.WhitePoint[1] * 50000);
+
+    	    metadata.MaxMasteringLuminance = 1000; // Pulled out of my ass, 10 times the SDR, whole nits
+    	    metadata.MinMasteringLuminance = 1000; // 0.1 nits = 1000 * 0.0001, black is black, 1/10000th of a nit
+
+    	    // Set content light levels (these are in actual nits)
+    	    metadata.MaxContentLightLevel = static_cast<UINT16>(displayDesc.MaxLuminance);
+    	    metadata.MaxFrameAverageLightLevel = static_cast<UINT16>(displayDesc.MaxFullFrameLuminance);
+
+    	    swapChain4->SetColorSpace1(DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020);
+    	    swapChain4->SetHDRMetaData(DXGI_HDR_METADATA_TYPE_HDR10, sizeof(metadata), &metadata);
+
+    		output6->Release();
+    		output->Release();
+    		swapChain4->Release();
+    	}
+	}
+
 	if (streamline->initialized) {
+		logger::info("[Hooks] Setting Streamline D3D device");
 		streamline->slSetD3DDevice(*ppDevice);
 		streamline->PostDevice();
 	}
@@ -563,12 +633,99 @@ namespace Hooks
 	{
 		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
 		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
 			globals::state->ModifyRenderTarget(a_target, a_properties);
 			func(This, a_target, a_properties);
 		}
 		static inline REL::Relocation<decltype(thunk)> func;
 	};
 
+	struct CreateRenderTarget_ImagespaceTempCopy
+	{
+		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
+		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
+			globals::state->ModifyRenderTarget(a_target, a_properties);
+			func(This, a_target, a_properties);
+		}
+
+		static inline REL::Relocation<decltype(thunk)> func;
+	};
+
+	struct CreateRenderTarget_ImagespaceTempCopy2
+	{
+		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
+		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
+			globals::state->ModifyRenderTarget(a_target, a_properties);
+			func(This, a_target, a_properties);
+		}
+
+		static inline REL::Relocation<decltype(thunk)> func;
+	};
+
+	struct CreateRenderTarget_LDRBlurSwap
+	{
+		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
+		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
+			globals::state->ModifyRenderTarget(a_target, a_properties);
+			func(This, a_target, a_properties);
+		}
+
+		static inline REL::Relocation<decltype(thunk)> func;
+	};
+
+	struct CreateRenderTarget_LDRDownsample
+	{
+		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
+		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
+			globals::state->ModifyRenderTarget(a_target, a_properties);
+			func(This, a_target, a_properties);
+		}
+
+		static inline REL::Relocation<decltype(thunk)> func;
+	};
+
+	struct CreateRenderTarget_TemporalAAAccumulation0
+	{
+		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
+		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
+			globals::state->ModifyRenderTarget(a_target, a_properties);
+			func(This, a_target, a_properties);
+		}
+
+		static inline REL::Relocation<decltype(thunk)> func;
+	};
+
+	struct CreateRenderTarget_TemporalAAAccumulation1
+	{
+		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
+		{
+			if (globals::state->IsHdrRendering()) {
+				a_properties->format = RE::BSGraphics::Format::kR16G16B16A16_FLOAT;
+			}
+			globals::state->ModifyRenderTarget(a_target, a_properties);
+			func(This, a_target, a_properties);
+		}
+
+		static inline REL::Relocation<decltype(thunk)> func;
+	};
+
 	struct CreateRenderTarget_Normals
 	{
 		static void thunk(RE::BSGraphics::Renderer* This, RE::RENDER_TARGETS::RENDER_TARGET a_target, RE::BSGraphics::RenderTargetProperties* a_properties)
@@ -958,6 +1115,12 @@ namespace Hooks
 
 		logger::info("Hooking BSShaderRenderTargets::Create::CreateRenderTarget(s)");
 		stl::write_thunk_call<CreateRenderTarget_Main>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x3F0, 0x3F3, 0x548));
+		stl::write_thunk_call<CreateRenderTarget_ImagespaceTempCopy>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x62F, 0x62E));
+		stl::write_thunk_call<CreateRenderTarget_ImagespaceTempCopy2>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x642, 0x641));
+		stl::write_thunk_call<CreateRenderTarget_LDRBlurSwap>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x529, 0x528));
+		stl::write_thunk_call<CreateRenderTarget_LDRDownsample>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0xB2E, 0xB2E));
+		stl::write_thunk_call<CreateRenderTarget_TemporalAAAccumulation0>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0xE68, 0xE6A));
+		stl::write_thunk_call<CreateRenderTarget_TemporalAAAccumulation1>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0xE7E, 0xE80));
 		stl::write_thunk_call<CreateRenderTarget_Normals>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x458, 0x45B, 0x5B0));
 		stl::write_thunk_call<CreateRenderTarget_NormalsSwap>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x46B, 0x46E, 0x5C3));
 		stl::write_thunk_call<CreateRenderTarget_Snow>(REL::RelocationID(100458, 107175).address() + REL::Relocate(0x406, 0x409, 0x55e));
diff --git a/src/Menu.cpp b/src/Menu.cpp
@@ -598,8 +598,116 @@ void Menu::DrawGeneralSettings()
 				ImGui::Text("Skips a shader being replaced if it hasn't been compiled yet. Also makes compilation blazingly fast!");
 			}
 
+			bool useHdrRendering = globals::state->IsHdrRendering();
+			ImGui::TableNextColumn();
+			if (ImGui::Checkbox("Enable HDR", &useHdrRendering)) {
+				globals::state->SetHdrRendering(useHdrRendering);
+			}
+			if (auto _tt = Util::HoverTooltipWrapper()) {
+				ImGui::Text("Vittu meni ikuisuus koodata -tssge");
+			}
+
 			ImGui::EndTable();
 		}
+
+		ImGui::Spacing();
+
+		// Get buffer description
+		DXGI_SWAP_CHAIN_DESC swapChainDesc;
+		globals::d3d::swapChain->GetDesc(&swapChainDesc);
+
+		ImGui::Text("Buffer format: %s",
+			swapChainDesc.BufferDesc.Format == DXGI_FORMAT_R8G8B8A8_UNORM     ? "RGBA8_UNORM" :
+			swapChainDesc.BufferDesc.Format == DXGI_FORMAT_R10G10B10A2_UNORM  ? "RGB10A2_UNORM" :
+			swapChainDesc.BufferDesc.Format == DXGI_FORMAT_R16G16B16A16_FLOAT ? "RGBA16_FLOAT" :
+																				"Other");
+		ImGui::Text("Buffer size: %dx%d",
+			swapChainDesc.BufferDesc.Width,
+			swapChainDesc.BufferDesc.Height);
+		ImGui::Text("Buffer count: %d", swapChainDesc.BufferCount);
+		ImGui::Text("Refresh rate: %d/%d Hz",
+			swapChainDesc.BufferDesc.RefreshRate.Numerator,
+			swapChainDesc.BufferDesc.RefreshRate.Denominator);
+
+		// Check VRR
+		BOOL allowTearing = FALSE;
+		if (IDXGIFactory5* factory = nullptr; SUCCEEDED(CreateDXGIFactory2(0, IID_PPV_ARGS(&factory)))) {
+			factory->CheckFeatureSupport(DXGI_FEATURE_PRESENT_ALLOW_TEARING, &allowTearing, sizeof(allowTearing));
+			factory->Release();
+		}
+		ImGui::Text("VRR Support: %s", allowTearing ? "Yes" : "No");
+
+		// Get HDR metadata and display capabilities
+		if (IDXGISwapChain4* swapChain4 = nullptr;
+			SUCCEEDED(globals::d3d::swapChain->QueryInterface(__uuidof(IDXGISwapChain4), (void**)&swapChain4))) {
+			ImGui::Spacing();
+
+			// Get display capabilities
+			IDXGIOutput* output = nullptr;
+			if (SUCCEEDED(globals::d3d::swapChain->GetContainingOutput(&output))) {
+				IDXGIOutput6* output6 = nullptr;
+				if (SUCCEEDED(output->QueryInterface(IID_PPV_ARGS(&output6)))) {
+					DXGI_OUTPUT_DESC1 desc1;
+					if (SUCCEEDED(output6->GetDesc1(&desc1))) {
+						ImGui::Spacing();
+						ImGui::Text("Display Capabilities:");
+						ImGui::Text("HDR Support: %s", desc1.ColorSpace == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 ? "Yes" : "No");
+						ImGui::Text("Display Max Luminance: %.2f nits", desc1.MaxLuminance);
+						ImGui::Text("Display Min Luminance: %.2f nits", desc1.MinLuminance);
+						ImGui::Text("Max Full Frame Luminance: %.2f nits", desc1.MaxFullFrameLuminance);
+
+						const char* bpcStr = "Unknown";
+						switch (desc1.BitsPerColor) {
+						case 8:
+							bpcStr = "8-bit";
+							break;
+						case 10:
+							bpcStr = "10-bit";
+							break;
+						case 12:
+							bpcStr = "12-bit";
+							break;
+						case 16:
+							bpcStr = "16-bit";
+							break;
+						}
+						ImGui::Text("Bits Per Channel: %s", bpcStr);
+					}
+					output6->Release();
+				}
+				output->Release();
+			}
+
+			swapChain4->Release();
+		}
+
+		// D3D12 Proxy Section
+		ImGui::Spacing();
+		ImGui::Text("D3D12 Proxy Swapchain Info:");
+
+		if (DX12SwapChain* dx12 = DX12SwapChain::GetSingleton()) {
+			if (dx12->swapChain) {
+				DXGI_SWAP_CHAIN_DESC1 desc12 = dx12->swapChainDesc;  // Using the stored desc
+
+				ImGui::Text("Buffer format: %s",
+					desc12.Format == DXGI_FORMAT_R8G8B8A8_UNORM     ? "RGBA8_UNORM" :
+					desc12.Format == DXGI_FORMAT_R10G10B10A2_UNORM  ? "RGB10A2_UNORM" :
+					desc12.Format == DXGI_FORMAT_R16G16B16A16_FLOAT ? "RGBA16_FLOAT" :
+																	  "Other");
+				ImGui::Text("Buffer size: %dx%d", desc12.Width, desc12.Height);
+				ImGui::Text("Buffer count: %d", desc12.BufferCount);
+
+				// Add refresh rate info if available
+				if (dx12->refreshRate > 0) {
+					ImGui::Text("Refresh Rate: %.2f Hz", dx12->refreshRate);
+				}
+
+			} else {
+				ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "DX12 swapchain not initialized");
+			}
+		} else {
+			ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "DX12 proxy not available");
+		}
 	}
 
 	if (ImGui::CollapsingHeader("Keybindings", ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick)) {
diff --git a/src/Menu.h b/src/Menu.h
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <d3d11.h>  // For D3D11 types
 #include <dxgi1_4.h>
+#include <dxgi1_6.h>  // For advanced DXGI features
 
 using namespace std::chrono;
 #define BUFFER_VIEWER_NODE(a_value, a_scale)                                                                 \
diff --git a/src/ShaderCache.h b/src/ShaderCache.h
@@ -322,7 +322,6 @@ namespace SIE
 		void SetAsync(bool value);
 		bool IsDump() const;
 		void SetDump(bool value);
-
 		bool IsDiskCache() const;
 		void SetDiskCache(bool value);
 		void DeleteDiskCache();
@@ -660,6 +659,7 @@ namespace SIE
 		bool isEnabled = true;
 		bool isDiskCache = true;
 		bool isAsync = true;
+		bool isHdrRendering = true;
 		bool isDump = false;
 		bool hideError = false;
 		bool useFileWatcher = false;
diff --git a/src/State.cpp b/src/State.cpp
diff --git a/src/State.h b/src/State.h
diff --git a/src/Streamline.cpp b/src/Streamline.cpp
diff --git a/src/Upscaling.cpp b/src/Upscaling.cpp
