From 09e56debd7944d374c39520da38ddea1d2172215 Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Fri, 6 Feb 2026 00:33:47 +0100 Subject: [PATCH 01/11] BioShock Infinite: Clamp object highlight cause it gets boosted by the bloom --- ..._ObjectHighlightRed_0x61D986B8.ps_5_0.hlsl | 215 ++++++++++++++++++ ...bjectHighlightWhite_0x4D93743F.ps_5_0.hlsl | 104 +++++++++ 2 files changed, 319 insertions(+) create mode 100644 Shaders/BioShock Series/BSI_ObjectHighlightRed_0x61D986B8.ps_5_0.hlsl create mode 100644 Shaders/BioShock Series/BSI_ObjectHighlightWhite_0x4D93743F.ps_5_0.hlsl diff --git a/Shaders/BioShock Series/BSI_ObjectHighlightRed_0x61D986B8.ps_5_0.hlsl b/Shaders/BioShock Series/BSI_ObjectHighlightRed_0x61D986B8.ps_5_0.hlsl new file mode 100644 index 00000000..aad20d1a --- /dev/null +++ b/Shaders/BioShock Series/BSI_ObjectHighlightRed_0x61D986B8.ps_5_0.hlsl @@ -0,0 +1,215 @@ +cbuffer _Globals : register(b0) +{ + float4x4 LocalToWorld : packoffset(c0); + float4x4 InvViewProjectionMatrix : packoffset(c4); + float3 CameraWorldPos : packoffset(c8); + float4 ObjectWorldPositionAndRadius : packoffset(c9); + float3 ObjectOrientation : packoffset(c10); + float3 ObjectPostProjectionPosition : packoffset(c11); + float3 ObjectNDCPosition : packoffset(c12); + float4 ObjectMacroUVScales : packoffset(c13); + float3 FoliageImpulseDirection : packoffset(c14); + float4 FoliageNormalizedRotationAxisAndAngle : packoffset(c15); + float4 WindDirectionAndSpeed : packoffset(c16); + float3 CameraWorldDirection : packoffset(c17) = {1,0,0}; + float4 ObjectOriginAndPrimitiveID : packoffset(c18) = {0,0,0,0}; + float4 UniformPixelVector_0 : packoffset(c19); + float4 UniformPixelVector_1 : packoffset(c20); + float4 UniformPixelVector_2 : packoffset(c21); + float4 UniformPixelVector_3 : packoffset(c22); + float4 UniformPixelVector_4 : packoffset(c23); + float4 UniformPixelVector_5 : packoffset(c24); + float4 UniformPixelVector_6 : packoffset(c25); + float4 UniformPixelVector_7 : packoffset(c26); + float4 UniformPixelVector_8 : packoffset(c27); + float4 UniformPixelVector_9 : packoffset(c28); + float4 UniformPixelVector_10 : packoffset(c29); + float4 UniformPixelScalars_0 : packoffset(c30); + float4 UniformPixelScalars_1 : packoffset(c31); + float4 UniformPixelScalars_2 : packoffset(c32); + float4 UniformPixelScalars_3 : packoffset(c33); + float4 UniformPixelScalars_4 : packoffset(c34); + float4 UniformPixelScalars_5 : packoffset(c35); + float4 UniformVertexScalars_0 : packoffset(c36); + float LocalToWorldRotDeterminantFlip : packoffset(c37); + float4 LightmapCoordinateScaleBias : packoffset(c38); + float3x3 WorldToLocal : packoffset(c39); + float3 MeshOrigin : packoffset(c42); + float3 MeshExtension : packoffset(c43); + float3 IrradianceUVWScale : packoffset(c44); + float3 IrradianceUVWBias : packoffset(c45); + float4 LightVolumeScaleAndAverageDynamicSkylightIntensity : packoffset(c46); + float3 CubeMapHDRScale : packoffset(c47); + float3 LightMapCofficientScale : packoffset(c48); + float4 GlobalLightMapScaleAndAverageDynamicSkylightIntensity : packoffset(c49); + float4 BaseVolumeRawBand0 : packoffset(c50); + float4 BaseVolumeRawLinearSH : packoffset(c51); +} + +cbuffer PSOffsetConstants : register(b2) +{ + float4 ScreenPositionScaleBias : packoffset(c0); + float4 MinZ_MaxZRatio : packoffset(c1); + float NvStereoEnabled : packoffset(c2); +} + +SamplerState Texture2D_0_s : register(s0); +SamplerState Texture2D_1_s : register(s1); +SamplerState MaterialBufferTexture_s : register(s2); +SamplerState CubeMapProbeTexture_s : register(s3); +SamplerState DiffuseLightingTexture_s : register(s4); +SamplerState SpecularLightingTexture_s : register(s5); +SamplerState IrradianceVolumeTextureBand0SH_s : register(s6); +SamplerState IrradianceVolumeTextureLinearSH_s : register(s7); +Texture3D IrradianceVolumeTextureBand0SH : register(t0); +Texture3D IrradianceVolumeTextureLinearSH : register(t1); +Texture2D MaterialBufferTexture : register(t2); +Texture2D Texture2D_1 : register(t3); +Texture2D Texture2D_0 : register(t4); +Texture2D DiffuseLightingTexture : register(t5); +Texture2D SpecularLightingTexture : register(t6); +TextureCube CubeMapProbeTexture : register(t7); + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : COLOR0, + float4 v1 : TEXCOORD0, + float4 v2 : TEXCOORD5, + float4 v3 : TEXCOORD6, + float4 v4 : TEXCOORD7, + float4 v5 : TEXCOORD8, + uint v6 : SV_IsFrontFace0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1,r2,r3,r4,r5; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyzw = IrradianceVolumeTextureBand0SH.Sample(IrradianceVolumeTextureBand0SH_s, v5.xyz).xyzw; + r1.xyzw = BaseVolumeRawBand0.xyzw + -r0.xyzw; + r2.x = saturate(v5.w); + r0.xyzw = r2.xxxx * r1.xyzw + r0.xyzw; + r1.x = r0.w; + r3.xyzw = IrradianceVolumeTextureLinearSH.Sample(IrradianceVolumeTextureLinearSH_s, v5.xyz).xyzw; + r4.xyzw = BaseVolumeRawLinearSH.xyzw + -r3.xyzw; + r2.xyzw = r2.xxxx * r4.xyzw + r3.xyzw; + r1.y = r2.w; + r2.xyz = r2.xyz * float3(2,2,2) + float3(-1,-1,-1); + r1.xy = r1.xy * r1.xy; + r0.w = 10 * r1.y; + r1.x = r1.x * 10 + 0.100000001; + r0.xyz = r1.xxx * r0.xyz; + r1.yzw = r2.xyz * r0.www; + r0.w = dot(r0.xyz, r0.xyz); + r0.w = sqrt(r0.w); + r1.x = 9.99999975e-005 + r0.w; + r2.xyzw = float4(-1,-1,1,0.295409203) * r1.wyzx; + r0.w = dot(r2.xyz, r2.xyz); + r0.w = sqrt(r0.w); + r2.xyz = r2.xyz / r0.www; + r0.w = cmp(r0.w == 0.000000); + r2.xyz = r0.www ? float3(0,0,0) : r2.xyz; + r3.yzw = float3(-0.488602996,0.488602996,-0.488602996) * r2.yzx; + r3.x = 0.282094985; + r0.w = dot(r3.xyzw, r1.xyzw); + r0.w = max(0, r0.w); + r3.xyzw = -r3.xyzw * r0.wwww + r1.xyzw; + r0.xyz = r0.xyz / r1.xxx; + r0.xyz = LightVolumeScaleAndAverageDynamicSkylightIntensity.xyz * r0.xyz; + r1.x = 3.14159274; + r4.xy = v2.xy / v2.ww; + r4.xy = r4.xy * ScreenPositionScaleBias.xy + ScreenPositionScaleBias.wz; + r5.xyz = MaterialBufferTexture.Sample(MaterialBufferTexture_s, r4.xy).xyz; + r5.xyz = r5.yzx * float3(2,2,2) + float3(-1,-1,-1); + r4.z = dot(r5.xyz, r5.xyz); + r4.z = rsqrt(r4.z); + r1.yzw = r5.xyz * r4.zzz; + r5.xyzw = float4(0.282094985,-1.02332771,1.02332771,-1.02332771) * r1.xyzw; + r1.x = dot(r5.xyzw, r3.xyzw); + r1.x = max(0, r1.x); + r3.xyzw = r1.xxxx * r0.xyzz; + r5.xyzw = r0.xyzz * r0.wwww; + r0.x = dot(r2.www, r0.xyz); + r0.y = saturate(dot(r2.yzx, r1.yzw)); + r2.xyzw = r0.yyyy * r5.xyzw + r3.xyzw; + r0.yzw = DiffuseLightingTexture.Sample(DiffuseLightingTexture_s, r4.xy).xyz; + r3.xyz = SpecularLightingTexture.Sample(SpecularLightingTexture_s, r4.xy).xyz; + r2.xyzw = r0.yzww + r2.xyzw; + r0.yzw = Texture2D_1.Sample(Texture2D_1_s, v1.xy).xyz; + r4.xyzw = UniformPixelVector_8.xyzz * r0.yzww; + r0.yz = Texture2D_0.Sample(Texture2D_0_s, v1.xy).yz; + r0.w = r0.y * r0.y; + r0.w = r0.w * 512 + 5; + r0.w = 0.159154937 * r0.w; + r5.xyzw = UniformPixelVector_10.xyzz * r0.wwww; + r3.xyzw = r5.xyzw * r3.xyzz; + r2.xyzw = r4.xyzw * r2.xyzw + r3.xyzw; + r0.w = LightVolumeScaleAndAverageDynamicSkylightIntensity.w + r0.x; + r0.x = 0.100000001 * r0.x; + r0.x = max(r0.w, r0.x); + r0.w = dot(-v4.xyz, -v4.xyz); + r0.w = rsqrt(r0.w); + r3.xyz = -v4.xyz * r0.www; + r0.w = dot(r1.wyz, r3.xyz); + r1.xyz = r1.wyz * r0.www; + r1.xyz = r1.xyz * float3(2,2,2) + -r3.xyz; + r0.y = 1 + -r0.y; + r3.xyzw = UniformPixelVector_2.xyzz * r0.zzzz; + r0.y = 5 * r0.y; + r0.yzw = CubeMapProbeTexture.SampleLevel(CubeMapProbeTexture_s, r1.xyz, r0.y).xyz; + r1.xyzw = CubeMapHDRScale.xyzz * r0.yzww; + r1.xyzw = UniformPixelVector_10.xyzz * r1.xyzw; + r0.xyzw = r0.xxxx * r1.xyzw + r2.xyzw; + r1.xy = CameraWorldPos.xz + v4.xz; + r1.zw = float2(-100,-50) + ObjectWorldPositionAndRadius.xz; + r1.xy = r1.xy + -r1.zw; + r1.z = 0.00249999994 * ObjectWorldPositionAndRadius.w; + r1.xy = r1.xy * float2(0.00300000003,0.00300000003) + r1.zz; + r1.x = r1.x + -r1.y; + r1.x = UniformPixelScalars_0.z * r1.x + r1.y; + r1.y = saturate(r1.x); + r1.x = 1 + -r1.x; + r1.z = log2(r1.y); + r1.y = cmp(r1.y < 9.99999997e-007); + r1.w = UniformPixelScalars_2.z * -30 + 30; + r1.z = r1.w * r1.z; + r1.z = exp2(r1.z); + r1.y = r1.y ? 0 : r1.z; + r1.z = log2(abs(r1.x)); + r1.x = cmp(abs(r1.x) < 9.99999997e-007); + r1.w = 30 * UniformPixelScalars_3.z; + r1.z = r1.w * r1.z; + r1.z = exp2(r1.z); + r1.x = r1.x ? 0 : r1.z; + r1.x = r1.y * r1.x; + r1.y = cmp(0.75 < UniformPixelScalars_4.w); + r1.y = r1.y ? 1.000000 : 0; + r1.x = r1.x * r1.y; + r1.xyzw = UniformPixelVector_6.xyzz * r1.xxxx; + r2.x = dot(v3.xyz, v3.xyz); + r2.x = rsqrt(r2.x); + r2.x = v3.z * r2.x; + r2.x = max(0, r2.x); + r2.x = 1 + -r2.x; + r2.y = rsqrt(abs(r2.x)); + r2.x = cmp(abs(r2.x) < 9.99999997e-007); + r2.y = 1 / r2.y; + r2.x = r2.x ? 0 : r2.y; + r2.y = log2(r2.x); + r2.x = cmp(r2.x < 9.99999997e-007); + r2.y = 1.35000002 * r2.y; + r2.y = exp2(r2.y); + r2.y = 5 * r2.y; + r2.x = r2.x ? 0 : r2.y; + r1.xyzw = r2.xxxx * r1.xyzw; + r1.xyzw = v0.xxxx * r1.xyzw; + r1.xyzw = UniformPixelScalars_5.xxxx * r1.xyzw; + r1.xyzw = UniformPixelScalars_0.xxxx * r3.xyzw + r1.xyzw; + r1.xyzw = UniformPixelVector_7.xyzz + r1.xyzw; + o0.xyzw = saturate(r1.xyzw + r0.xyzw); // Saturate cause it gets boosted by the bloom. + return; +} \ No newline at end of file diff --git a/Shaders/BioShock Series/BSI_ObjectHighlightWhite_0x4D93743F.ps_5_0.hlsl b/Shaders/BioShock Series/BSI_ObjectHighlightWhite_0x4D93743F.ps_5_0.hlsl new file mode 100644 index 00000000..0023a8ea --- /dev/null +++ b/Shaders/BioShock Series/BSI_ObjectHighlightWhite_0x4D93743F.ps_5_0.hlsl @@ -0,0 +1,104 @@ +cbuffer _Globals : register(b0) +{ + float4x4 LocalToWorld : packoffset(c0); + float4x4 InvViewProjectionMatrix : packoffset(c4); + float3 CameraWorldPos : packoffset(c8); + float4 ObjectWorldPositionAndRadius : packoffset(c9); + float3 ObjectOrientation : packoffset(c10); + float3 ObjectPostProjectionPosition : packoffset(c11); + float3 ObjectNDCPosition : packoffset(c12); + float4 ObjectMacroUVScales : packoffset(c13); + float3 FoliageImpulseDirection : packoffset(c14); + float4 FoliageNormalizedRotationAxisAndAngle : packoffset(c15); + float4 WindDirectionAndSpeed : packoffset(c16); + float3 CameraWorldDirection : packoffset(c17) = {1,0,0}; + float4 ObjectOriginAndPrimitiveID : packoffset(c18) = {0,0,0,0}; + float4 UniformPixelVector_0 : packoffset(c19); + float4 UniformPixelVector_1 : packoffset(c20); + float4 UniformPixelVector_2 : packoffset(c21); + float4 UniformPixelVector_3 : packoffset(c22); + float4 UniformPixelVector_4 : packoffset(c23); + float4 UniformPixelVector_5 : packoffset(c24); + float4 UniformPixelVector_6 : packoffset(c25); + float4 UniformPixelVector_7 : packoffset(c26); + float4 UniformPixelScalars_0 : packoffset(c27); + float4 UniformPixelScalars_1 : packoffset(c28); + float4 UniformPixelScalars_2 : packoffset(c29); + float4 UniformPixelScalars_3 : packoffset(c30); + float4 UniformPixelScalars_4 : packoffset(c31); + float LocalToWorldRotDeterminantFlip : packoffset(c32); + float4 LightmapCoordinateScaleBias : packoffset(c33); + float3x3 WorldToLocal : packoffset(c34); + float3 MeshOrigin : packoffset(c37); + float3 MeshExtension : packoffset(c38); + float3 IrradianceUVWScale : packoffset(c39); + float3 IrradianceUVWBias : packoffset(c40); + float AverageDynamicSkylightIntensity : packoffset(c40.w); + float4 LightEnvironmentRedAndGreenUV : packoffset(c41); + float2 LightEnvironmentBlueUV : packoffset(c42); +} + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : TEXCOORD0, + float4 v1 : TEXCOORD4, + float4 v2 : TEXCOORD5, + float4 v3 : TEXCOORD6, + float4 v4 : TEXCOORD7, + uint v5 : SV_IsFrontFace0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = CameraWorldPos.xz + v4.xz; + r0.zw = float2(-100,-50) + ObjectWorldPositionAndRadius.xz; + r0.xy = r0.xy + -r0.zw; + r0.z = 0.00249999994 * ObjectWorldPositionAndRadius.w; + r0.xy = r0.xy * float2(0.00300000003,0.00300000003) + r0.zz; + r0.x = r0.x + -r0.y; + r0.x = UniformPixelScalars_0.y * r0.x + r0.y; + r0.y = saturate(r0.x); + r0.x = 1 + -r0.x; + r0.z = log2(r0.y); + r0.y = cmp(r0.y < 9.99999997e-007); + r0.w = UniformPixelScalars_2.y * -30 + 30; + r0.z = r0.w * r0.z; + r0.z = exp2(r0.z); + r0.y = r0.y ? 0 : r0.z; + r0.z = log2(abs(r0.x)); + r0.x = cmp(abs(r0.x) < 9.99999997e-007); + r0.w = 30 * UniformPixelScalars_3.y; + r0.z = r0.w * r0.z; + r0.z = exp2(r0.z); + r0.x = r0.x ? 0 : r0.z; + r0.x = r0.y * r0.x; + r0.y = cmp(0.75 < UniformPixelScalars_4.z); + r0.y = r0.y ? 1.000000 : 0; + r0.x = r0.x * r0.y; + r0.xyz = UniformPixelVector_4.xyz * r0.xxx; + r0.w = dot(v3.xyz, v3.xyz); + r0.w = rsqrt(r0.w); + r0.w = v3.z * r0.w; + r0.w = max(0, r0.w); + r0.w = 1 + -r0.w; + r1.x = rsqrt(abs(r0.w)); + r0.w = cmp(abs(r0.w) < 9.99999997e-007); + r1.x = 1 / r1.x; + r0.w = r0.w ? 0 : r1.x; + r1.x = log2(r0.w); + r0.w = cmp(r0.w < 9.99999997e-007); + r1.x = 1.35000002 * r1.x; + r1.x = exp2(r1.x); + r1.x = 5 * r1.x; + r0.w = r0.w ? 0 : r1.x; + r0.xyz = r0.www * r0.xyz + UniformPixelVector_5.xyz; + o0.xyz = saturate(v1.www * r0.xyz); // Saturate cause it gets boosted by the bloom. + o0.w = 0; + return; +} \ No newline at end of file From 07bed7683218368c19a7a0c631f5e94df2d5565f Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Fri, 6 Feb 2026 01:27:43 +0100 Subject: [PATCH 02/11] BioShock Infinite: Add option to disable lens dirt --- ..._Starburst_LensDirt_0x2AD953ED.ps_5_0.hlsl | 138 ++++++++++++++++++ Source/Games/BioShock Series/main.cpp | 1 + 2 files changed, 139 insertions(+) create mode 100644 Shaders/BioShock Series/BSI_Starburst_LensDirt_0x2AD953ED.ps_5_0.hlsl diff --git a/Shaders/BioShock Series/BSI_Starburst_LensDirt_0x2AD953ED.ps_5_0.hlsl b/Shaders/BioShock Series/BSI_Starburst_LensDirt_0x2AD953ED.ps_5_0.hlsl new file mode 100644 index 00000000..7256aefd --- /dev/null +++ b/Shaders/BioShock Series/BSI_Starburst_LensDirt_0x2AD953ED.ps_5_0.hlsl @@ -0,0 +1,138 @@ +cbuffer _Globals : register(b0) +{ + float4x4 LocalToWorld : packoffset(c0); + float4x4 InvViewProjectionMatrix : packoffset(c4); + float3 CameraWorldPos : packoffset(c8); + float4 ObjectWorldPositionAndRadius : packoffset(c9); + float3 ObjectOrientation : packoffset(c10); + float3 ObjectPostProjectionPosition : packoffset(c11); + float3 ObjectNDCPosition : packoffset(c12); + float4 ObjectMacroUVScales : packoffset(c13); + float3 FoliageImpulseDirection : packoffset(c14); + float4 FoliageNormalizedRotationAxisAndAngle : packoffset(c15); + float4 WindDirectionAndSpeed : packoffset(c16); + float3 CameraWorldDirection : packoffset(c17) = {1,0,0}; + float4 ObjectOriginAndPrimitiveID : packoffset(c18) = {0,0,0,0}; + float OcclusionPercentage : packoffset(c19); + float4 UniformPixelVector_0 : packoffset(c20); + float4 UniformPixelVector_1 : packoffset(c21); + float4 UniformPixelVector_2 : packoffset(c22); + float4 UniformPixelVector_3 : packoffset(c23); + float4 UniformPixelVector_4 : packoffset(c24); + float4 UniformPixelVector_5 : packoffset(c25); + float4 UniformPixelScalars_0 : packoffset(c26); + float4 UniformPixelScalars_1 : packoffset(c27); + float4 UniformPixelScalars_2 : packoffset(c28); + float4 CameraRight : packoffset(c29); + float4 CameraUp : packoffset(c30); + float3 IrradianceUVWScale : packoffset(c31); + float3 IrradianceUVWBias : packoffset(c32); + float AverageDynamicSkylightIntensity : packoffset(c32.w); + float4 LightEnvironmentRedAndGreenUV : packoffset(c33); + float2 LightEnvironmentBlueUV : packoffset(c34); +} + +cbuffer PSOffsetConstants : register(b2) +{ + float4 ScreenPositionScaleBias : packoffset(c0); + float4 MinZ_MaxZRatio : packoffset(c1); + float NvStereoEnabled : packoffset(c2); +} + +SamplerState Texture2D_0_s : register(s0); +SamplerState Texture2D_1_s : register(s1); +SamplerState Texture2D_2_s : register(s2); +SamplerState Texture2D_3_s : register(s3); +Texture2D Texture2D_0 : register(t0); // Starburst. +Texture2D Texture2D_1 : register(t1); // Lens dirt. +Texture2D Texture2D_2 : register(t2); // Lens dirt. +Texture2D Texture2D_3 : register(t3); // Lens dirt. + +#ifndef DISABLE_LENS_DIRT +#define DISABLE_LENS_DIRT 0 +#endif + +// 3Dmigoto declarations +#define cmp - + +void main( + float4 v0 : TEXCOORD0, + float4 v1 : TEXCOORD1, + float4 v2 : TEXCOORD2, + float4 v3 : TEXCOORD4, + float4 v4 : TEXCOORD5, + float4 v5 : TEXCOORD6, + float4 v6 : TEXCOORD7, + uint v7 : SV_IsFrontFace0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyzw = v4.xyxy / v4.wwww; + r0.xyzw = r0.xyzw * ScreenPositionScaleBias.xyxy + ScreenPositionScaleBias.wzwz; + r0.xy = r0.xy * float2(1,0.0199999996) + UniformPixelVector_2.xy; + + #if DISABLE_LENS_DIRT + r0.x = 0.0; + r0.y = 0.0; + #else + r0.x = Texture2D_2.Sample(Texture2D_2_s, r0.xy).y; + r0.y = Texture2D_1.Sample(Texture2D_1_s, r0.zw).y; + #endif + + r0.x = r0.x * r0.y; + r1.xyzw = float4(-0.300000012,-0.5,0.300000012,0.300000012) + r0.zwzw; + r0.yz = float2(1.20000005,1.29999995) * r0.zw; + + #if DISABLE_LENS_DIRT + r0.y = 0.0; + #else + r0.y = Texture2D_3.Sample(Texture2D_3_s, r0.yz).y; + #endif + + r0.y = UniformPixelScalars_2.y * r0.y; + r0.zw = float2(0.800000012,0.899999976) * r1.zw; + + #if DISABLE_LENS_DIRT + r0.z = 0.0; + #else + r0.z = Texture2D_1.Sample(Texture2D_1_s, r0.zw).y; + #endif + + r1.zw = r1.zw * float2(0.800000012,0.0359999985) + UniformPixelVector_2.xy; + + #if DISABLE_LENS_DIRT + r0.w = 0.0; + #else + r0.w = Texture2D_2.Sample(Texture2D_2_s, r1.zw).y; + #endif + + r0.x = r0.w * r0.z + r0.x; + r0.zw = float2(1.29999995,1.39999998) * r1.xy; + r1.xy = r1.xy * float2(1.29999995,0.027999999) + UniformPixelVector_1.xy; + + #if DISABLE_LENS_DIRT + r1.x = 0.0; + r0.z = 0.0; + #else + r1.x = Texture2D_2.Sample(Texture2D_2_s, r1.xy).y; + r0.z = Texture2D_1.Sample(Texture2D_1_s, r0.zw).y; + #endif + + r0.x = r1.x * r0.z + r0.x; + r0.x = r0.x * UniformPixelScalars_2.x + r0.y; + r0.yzw = Texture2D_0.Sample(Texture2D_0_s, v0.xy).xyz; + r0.yzw = v1.xyz * r0.yzw; + r0.yzw = OcclusionPercentage * r0.yzw; + r0.yzw = UniformPixelScalars_0.xxx * r0.yzw; + r0.xyz = r0.xxx * r0.yzw + r0.yzw; + r0.xyz = v2.www * r0.xyz; + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = min(float3(500,500,500), r0.xyz); + r0.xyz = UniformPixelVector_3.xyz + r0.xyz; + o0.xyz = v3.www * r0.xyz; + o0.w = 0; + return; +} \ No newline at end of file diff --git a/Source/Games/BioShock Series/main.cpp b/Source/Games/BioShock Series/main.cpp index aaba1195..1287e102 100644 --- a/Source/Games/BioShock Series/main.cpp +++ b/Source/Games/BioShock Series/main.cpp @@ -199,6 +199,7 @@ class BioshockSeries final : public Game { game_shader_defines_data.push_back({ "GAME_BIOSHOCK", '3', true, true }); game_shader_defines_data.push_back({ "XE_GTAO_QUALITY", '2', true, false, "0 - Low\n1 - Medium\n2 - High\n3 - Very High\n4 - Ultra", 4 }); + game_shader_defines_data.push_back({ "DISABLE_LENS_DIRT", '0', true, false, "Disables lens dirt.", 1 }); } shader_defines_data.append_range(game_shader_defines_data); From f46d20ed4bc5f9859abecd2a6628f196fa3952de Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Sun, 22 Feb 2026 18:57:57 +0100 Subject: [PATCH 03/11] BioShock Series: BS2 fix DISABLE_BLACK_BARS setting --- .../BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl | 12 ++++++++++-- Source/Games/BioShock Series/main.cpp | 2 +- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl b/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl index 4043f0c5..13a93b98 100644 --- a/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl +++ b/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl @@ -5,8 +5,16 @@ void main( float4 v1 : COLOR0, out float4 o0 : SV_Target0) { -#if DISABLE_BLACK_BARS // TODO: does this draw anything else? Probably!!! Default to true if we can fix it, but we'd need to analyze the VS. Maybe the VS color. - o0.xyzw = 0; +#if DISABLE_BLACK_BARS + // Check is the color black. + // Alpha blending is used. + // + // Besides black bars this renders some elenments on the map, + // including black elemets. But it may not be a significant issue (eg. black outline to red arrow). + if (length(v1.xyz) <= 1e-6) { + o0.xyzw = 0; + } + o0.xyzw = v1.xyzw; #else o0.xyzw = v1.xyzw; #endif diff --git a/Source/Games/BioShock Series/main.cpp b/Source/Games/BioShock Series/main.cpp index 1287e102..c6046dbe 100644 --- a/Source/Games/BioShock Series/main.cpp +++ b/Source/Games/BioShock Series/main.cpp @@ -173,7 +173,7 @@ class BioshockSeries final : public Game {"ENABLE_LUT_EXTRAPOLATION", '1', true, false, "Use Luma's signature technique for expanding Color Grading LUTs from SDR to HDR", 1}, {"ENABLE_COLOR_GRADING", '1', true, false, "Allows disabling the color grading LUT (some other color filters might still get applied)", 1}, {"DISABLE_BLACK_BARS", '0', true, false, - "Disable broken black bars in UltraWide in BioShock 2, given that they only cover an horizontal part of the screen, leaving the vertical view visible.\nThis will remove them from 16:9 too", 1}, // TODO: fix this. It breaks the minimap in BS2. We could simply skip drawing the shader if its run immediately after scene rendering, before UI, and has a specific vertex shader + "Disable broken black bars in UltraWide in BioShock 2, given that they only cover an horizontal part of the screen, leaving the vertical view visible.\nThis will remove them from 16:9 too.\nIt will also remove some other black UI elements, but it may not be a significant issue.", 1}, {"LUT_SAMPLING_ERROR_EMULATION_MODE", '1', true, false, "BioShock 2 Remastered had a bug in the color grading shader that accidentally boosted contrast and clipped both shadow and highlight." "\nLuma fixes that, however without the bug shadows are fairly raised, so this attempts to emulate the error without clipping detail." From ff91d221f7237a875ec93f8b96a5ed766f76c4c1 Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Sun, 22 Feb 2026 19:11:23 +0100 Subject: [PATCH 04/11] BioShock 2: Actually fix black bars --- .../BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl b/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl index 13a93b98..60962e7a 100644 --- a/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl +++ b/Shaders/BioShock Series/BS2_UI_BlackBars_0x61085099.ps_4_0.hlsl @@ -11,10 +11,7 @@ void main( // // Besides black bars this renders some elenments on the map, // including black elemets. But it may not be a significant issue (eg. black outline to red arrow). - if (length(v1.xyz) <= 1e-6) { - o0.xyzw = 0; - } - o0.xyzw = v1.xyzw; + o0.xyzw = length(v1.xyz) <= 1e-6 ? 0.0 : v1.xyzw; #else o0.xyzw = v1.xyzw; #endif From 21d0d41d5c953d5f532515223a19521fc587ba6a Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Sun, 22 Feb 2026 19:54:33 +0100 Subject: [PATCH 05/11] Dishonored 2: DLSS, fix inverted_depth flag --- Source/Games/Dishonored 2/main.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index e9ac59a6..91df0a68 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -611,7 +611,7 @@ class Dishonored2 final : public Game settings_data.render_height = dlss_render_resolution[1]; settings_data.dynamic_resolution = game_device_data.prey_drs_detected; settings_data.hdr = true; // The "HDR" flag in DLSS SR actually means whether the color is in linear space or "sRGB gamma" (apparently not 2.2) (SDR) space, colors beyond 0-1 don't seem to be clipped either way - settings_data.inverted_depth = false; + settings_data.inverted_depth = true; settings_data.mvs_jittered = false; settings_data.render_preset = dlss_render_preset; sr_implementations[device_data.sr_type]->UpdateSettings(sr_instance_data, native_device_context, settings_data); @@ -936,7 +936,7 @@ class Dishonored2 final : public Game settings_data.render_height = dlss_render_resolution[1]; settings_data.dynamic_resolution = game_device_data.prey_drs_detected; settings_data.hdr = true; // The "HDR" flag in DLSS SR actually means whether the color is in linear space or "sRGB gamma" (apparently not 2.2) (SDR) space, colors beyond 0-1 don't seem to be clipped either way - settings_data.inverted_depth = false; + settings_data.inverted_depth = true; settings_data.mvs_jittered = false; settings_data.render_preset = dlss_render_preset; sr_implementations[device_data.sr_type]->UpdateSettings(sr_instance_data, native_device_context.get(), settings_data); From 95201b9c3e3893a444d12cbe7e70ccea5292f13d Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Sun, 22 Feb 2026 23:44:18 +0100 Subject: [PATCH 06/11] Dishonored 2: DLSS add exposure --- ... => LensDistortion_0x152A9E10.ps_5_0.hlsl} | 0 Shaders/Dishonored 2/Luma_Exposure.hlsl | 38 +++++++++++++ Source/Games/Dishonored 2/main.cpp | 53 +++++++++++++++++-- 3 files changed, 88 insertions(+), 3 deletions(-) rename Shaders/Dishonored 2/{Bloom_0x152A9E10.ps_5_0.hlsl => LensDistortion_0x152A9E10.ps_5_0.hlsl} (100%) create mode 100644 Shaders/Dishonored 2/Luma_Exposure.hlsl diff --git a/Shaders/Dishonored 2/Bloom_0x152A9E10.ps_5_0.hlsl b/Shaders/Dishonored 2/LensDistortion_0x152A9E10.ps_5_0.hlsl similarity index 100% rename from Shaders/Dishonored 2/Bloom_0x152A9E10.ps_5_0.hlsl rename to Shaders/Dishonored 2/LensDistortion_0x152A9E10.ps_5_0.hlsl diff --git a/Shaders/Dishonored 2/Luma_Exposure.hlsl b/Shaders/Dishonored 2/Luma_Exposure.hlsl new file mode 100644 index 00000000..95085de1 --- /dev/null +++ b/Shaders/Dishonored 2/Luma_Exposure.hlsl @@ -0,0 +1,38 @@ +struct postfx_luminance_autoexposure_t +{ + float EngineLuminanceFactor; // Offset: 0 + float LuminanceFactor; // Offset: 4 + float MinLuminanceLDR; // Offset: 8 + float MaxLuminanceLDR; // Offset: 12 + float MiddleGreyLuminanceLDR; // Offset: 16 + float EV; // Offset: 20 + float Fstop; // Offset: 24 + uint PeakHistogramValue; // Offset: 28 +}; + +cbuffer PerInstanceCB : register(b0) +{ + float4 cb_positiontoviewtexture : packoffset(c0); + float4 cb_taatexsize : packoffset(c1); + float4 cb_taaditherandviewportsize : packoffset(c2); + float4 cb_postfx_tonemapping_tonemappingparms : packoffset(c3); + float4 cb_postfx_tonemapping_tonemappingcoeffsinverse1 : packoffset(c4); + float4 cb_postfx_tonemapping_tonemappingcoeffsinverse0 : packoffset(c5); + float4 cb_postfx_tonemapping_tonemappingcoeffs1 : packoffset(c6); + float4 cb_postfx_tonemapping_tonemappingcoeffs0 : packoffset(c7); + uint2 cb_postfx_luminance_exposureindex : packoffset(c8); + float2 cb_prevresolutionscale : packoffset(c8.z); + float cb_env_tonemapping_white_level : packoffset(c9); + float cb_view_white_level : packoffset(c9.y); + float cb_taaamount : packoffset(c9.z); + float cb_postfx_luminance_customevbias : packoffset(c9.w); +} + +StructuredBuffer ro_postfx_luminance_buffautoexposure : register(t0); +RWTexture2D uav : register(u0); + +[numthreads(1, 1, 1)] +void main(uint3 dtid : SV_DispatchThreadID) +{ + uav[uint2(0,0)] = ro_postfx_luminance_buffautoexposure[cb_postfx_luminance_exposureindex.y].EV; +} \ No newline at end of file diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index 91df0a68..a4b35800 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -98,6 +98,11 @@ struct GameDeviceDataDishonored2 final : public GameDeviceData com_ptr sr_source_color; com_ptr sr_motion_vectors; //com_ptr sr_output_color_2; //TODOFT: delete this and related code + ComPtr sr_exposure; + + // We need these to get exposure. + ComPtr cb_taa_b2; + ComPtr srv_postfx_luminance_autoexposure; // Game state com_ptr depth_buffer; @@ -152,6 +157,7 @@ class Dishonored2 final : public Game native_shaders_definitions.emplace(CompileTimeStringHash("DS2 XeGTAO Prefilter Depths CS"), ShaderDefinition{ "Luma_XeGTAO", reshade::api::pipeline_subobject_type::compute_shader, nullptr, "prefilter_depths16x16_cs" }); native_shaders_definitions.emplace(CompileTimeStringHash("DS2 XeGTAO Main Pass PS"), ShaderDefinition{ "Luma_XeGTAO", reshade::api::pipeline_subobject_type::pixel_shader, nullptr, "main_pass_ps" }); + native_shaders_definitions.emplace(CompileTimeStringHash("DS2 Exposure CS"), ShaderDefinition{ "Luma_Exposure", reshade::api::pipeline_subobject_type::compute_shader }); } // This needs to be overridden with your own "GameDeviceData" sub-class (destruction is automatically handled) @@ -561,6 +567,12 @@ class Dishonored2 final : public Game // SR/TAA if (device_data.sr_type != SR::Type::None && !device_data.sr_suppressed && original_shader_hashes.Contains(shader_hashes_TAA)) { + native_device_context->CSGetConstantBuffers(2, 1, game_device_data.cb_taa_b2.put()); + native_device_context->CSGetShaderResources(3, 1, game_device_data.srv_postfx_luminance_autoexposure.put()); + + // TODO: Clean up all this, I think game will always use deferred rendering, so most of this is not needed. + assert(native_device_context->GetType() == D3D11_DEVICE_CONTEXT_DEFERRED); + com_ptr srvs[2]; // TODO: rename // 1 motion vectors // 2 color source (pre TAA, jittered) @@ -701,8 +713,8 @@ class Dishonored2 final : public Game // Theoretically knowing the average exposure of the frame would still be beneficial to it (somehow) so maybe we could simply let the auto exposure in, D3D11_SUBRESOURCE_DATA exposure_texture_data; exposure_texture_data.pSysMem = &sr_scene_exposure; // This needs to be "static" data in case the texture initialization was somehow delayed and read the data after the stack destroyed it - exposure_texture_data.SysMemPitch = 32; - exposure_texture_data.SysMemSlicePitch = 32; + exposure_texture_data.SysMemPitch = sizeof(float); + exposure_texture_data.SysMemSlicePitch = sizeof(float); device_data.sr_exposure = nullptr; // Make sure we discard the previous one hr = native_device->CreateTexture2D(&exposure_texture_desc, &exposure_texture_data, &device_data.sr_exposure); @@ -920,6 +932,41 @@ class Dishonored2 final : public Game // Do "delayed" DLSS: + // First we get exposure to 2D texture 1x1. + // + + ComPtr native_device; + native_device_context->GetDevice(native_device.put()); + + // Create RTs and views. + if (!game_device_data.sr_exposure) { + D3D11_TEXTURE2D_DESC tex_desc = {}; + tex_desc.Width = 1; + tex_desc.Height = 1; + tex_desc.MipLevels = 1; + tex_desc.ArraySize = 1; + tex_desc.Format = DXGI_FORMAT_R32_FLOAT; + tex_desc.SampleDesc.Count = 1; + tex_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS; + ensure(native_device->CreateTexture2D(&tex_desc, nullptr, game_device_data.sr_exposure.put()), >= 0); + } + ComPtr uav; + ensure(native_device->CreateUnorderedAccessView(game_device_data.sr_exposure.get(), nullptr, uav.put()), >= 0); + + // Bindings. + native_device_context->CSSetUnorderedAccessViews(0, 1, &uav, nullptr); + native_device_context->CSSetShader(device_data.native_compute_shaders.at(CompileTimeStringHash("DS2 Exposure CS")).get(), nullptr, 0); + native_device_context->CSSetConstantBuffers(0, 1, &game_device_data.cb_taa_b2); + native_device_context->CSSetShaderResources(0, 1, &game_device_data.srv_postfx_luminance_autoexposure); + + native_device_context->Dispatch(1, 1, 1); + + // Ubind UAV. + ID3D11UnorderedAccessView* uav_null = nullptr; + native_device_context->CSSetUnorderedAccessViews(0, 1, &uav_null, nullptr); + + // + DrawStateStack draw_state_stack; DrawStateStack compute_state_stack; draw_state_stack.Cache(native_device_context.get(), device_data.uav_max_count); @@ -953,7 +1000,7 @@ class Dishonored2 final : public Game draw_data.output_color = device_data.sr_output_color.get(); draw_data.motion_vectors = game_device_data.sr_motion_vectors.get(); draw_data.depth_buffer = game_device_data.depth_buffer.get(); - draw_data.exposure = device_data.sr_exposure.get(); + draw_data.exposure = game_device_data.sr_exposure.get(); draw_data.pre_exposure = dlss_pre_exposure; draw_data.jitter_x = projection_jitters.x; draw_data.jitter_y = projection_jitters.y; From 70d05119b57b9aaecbe54da7765ebdaa44c7737c Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Mon, 23 Feb 2026 00:32:11 +0100 Subject: [PATCH 07/11] Dishonored 2: DLSS, fix exploding highlights --- .../Downsample_0x42873B15.ps_5_0.hlsl | 109 ++++++++++++++++++ Source/Games/Dishonored 2/main.cpp | 7 ++ 2 files changed, 116 insertions(+) create mode 100644 Shaders/Dishonored 2/Downsample_0x42873B15.ps_5_0.hlsl diff --git a/Shaders/Dishonored 2/Downsample_0x42873B15.ps_5_0.hlsl b/Shaders/Dishonored 2/Downsample_0x42873B15.ps_5_0.hlsl new file mode 100644 index 00000000..9b749c62 --- /dev/null +++ b/Shaders/Dishonored 2/Downsample_0x42873B15.ps_5_0.hlsl @@ -0,0 +1,109 @@ +struct postfx_luminance_autoexposure_t +{ + float EngineLuminanceFactor; // Offset: 0 + float LuminanceFactor; // Offset: 4 + float MinLuminanceLDR; // Offset: 8 + float MaxLuminanceLDR; // Offset: 12 + float MiddleGreyLuminanceLDR; // Offset: 16 + float EV; // Offset: 20 + float Fstop; // Offset: 24 + uint PeakHistogramValue; // Offset: 28 +}; + +cbuffer PerInstanceCB : register(b2) +{ + float4 cb_positiontoviewtexture : packoffset(c0); + uint2 cb_postfx_luminance_exposureindex : packoffset(c1); + float cb_view_white_level : packoffset(c1.z); +} + +cbuffer PerViewCB : register(b1) +{ + float4 cb_alwaystweak : packoffset(c0); + float4 cb_viewrandom : packoffset(c1); + float4x4 cb_viewprojectionmatrix : packoffset(c2); + float4x4 cb_viewmatrix : packoffset(c6); + float4 cb_subpixeloffset : packoffset(c10); + float4x4 cb_projectionmatrix : packoffset(c11); + float4x4 cb_previousviewprojectionmatrix : packoffset(c15); + float4x4 cb_previousviewmatrix : packoffset(c19); + float4x4 cb_previousprojectionmatrix : packoffset(c23); + float4 cb_mousecursorposition : packoffset(c27); + float4 cb_mousebuttonsdown : packoffset(c28); + float4 cb_jittervectors : packoffset(c29); + float4x4 cb_inverseviewprojectionmatrix : packoffset(c30); + float4x4 cb_inverseviewmatrix : packoffset(c34); + float4x4 cb_inverseprojectionmatrix : packoffset(c38); + float4 cb_globalviewinfos : packoffset(c42); + float3 cb_wscamforwarddir : packoffset(c43); + uint cb_alwaysone : packoffset(c43.w); + float3 cb_wscamupdir : packoffset(c44); + uint cb_usecompressedhdrbuffers : packoffset(c44.w); + float3 cb_wscampos : packoffset(c45); + float cb_time : packoffset(c45.w); + float3 cb_wscamleftdir : packoffset(c46); + float cb_systime : packoffset(c46.w); + float2 cb_jitterrelativetopreviousframe : packoffset(c47); + float2 cb_worldtime : packoffset(c47.z); + float2 cb_shadowmapatlasslicedimensions : packoffset(c48); + float2 cb_resolutionscale : packoffset(c48.z); + float2 cb_parallelshadowmapslicedimensions : packoffset(c49); + float cb_framenumber : packoffset(c49.z); + uint cb_alwayszero : packoffset(c49.w); +} + +// From TAA. +// Some are renamed (prefix _) cause we already have them. +cbuffer PerInstanceCB : register(b3) +{ + float4 _cb_positiontoviewtexture : packoffset(c0); + float4 cb_taatexsize : packoffset(c1); + float4 cb_taaditherandviewportsize : packoffset(c2); + float4 cb_postfx_tonemapping_tonemappingparms : packoffset(c3); + float4 cb_postfx_tonemapping_tonemappingcoeffsinverse1 : packoffset(c4); + float4 cb_postfx_tonemapping_tonemappingcoeffsinverse0 : packoffset(c5); + float4 cb_postfx_tonemapping_tonemappingcoeffs1 : packoffset(c6); + float4 cb_postfx_tonemapping_tonemappingcoeffs0 : packoffset(c7); + uint2 _cb_postfx_luminance_exposureindex : packoffset(c8); + float2 cb_prevresolutionscale : packoffset(c8.z); + float cb_env_tonemapping_white_level : packoffset(c9); + float _cb_view_white_level : packoffset(c9.y); + float cb_taaamount : packoffset(c9.z); + float cb_postfx_luminance_customevbias : packoffset(c9.w); +} + +SamplerState smp_linearclamp_s : register(s0); +Texture2D ro_viewcolormap : register(t0); +StructuredBuffer ro_postfx_luminance_buffautoexposure : register(t1); + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_POSITION0, + out float4 o0 : SV_TARGET0) +{ + float4 r0,r1; + uint4 bitmask, uiDest; + float4 fDest; + + r0.x = ro_postfx_luminance_buffautoexposure[cb_postfx_luminance_exposureindex.y].EngineLuminanceFactor; + r0.x = cb_view_white_level * r0.x; + r0.yz = cb_positiontoviewtexture.zw * v0.xy; + r0.yzw = ro_viewcolormap.Sample(smp_linearclamp_s, r0.yz).xyz; + r1.xyz = r0.yzw * r0.xxx; + r0.xyz = cb_usecompressedhdrbuffers ? r1.xyz : r0.yzw; + r0.xyz = max(float3(0,0,0), r0.xyz); + + // Limit colors to cb_env_tonemapping_white_level, + // cause after DLSS pass highlihghts explode otherwise. + // + // We only need to do this in case of DLSS, but it doesnt hurt the native TAA. + r0.xyz = min(cb_env_tonemapping_white_level, r0.xyz); + + o0.w = dot(r0.xyz, float3(0.212599993,0.715200007,0.0722000003)); + o0.xyz = r0.xyz; + return; +} \ No newline at end of file diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index a4b35800..f0105791 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -56,6 +56,7 @@ namespace ShaderHashesList shader_hashes_DownsampleDepth; ShaderHashesList shader_hashes_UnprojectDepth; ShaderHashesList shader_hashes_SSAO; + ShaderHashesList shader_hashes_Downsample; // XeGTAO constexpr size_t XE_GTAO_DEPTH_MIP_LEVELS = 5; @@ -555,6 +556,11 @@ class Dishonored2 final : public Game } } + if (original_shader_hashes.Contains(shader_hashes_Downsample)) + { + native_device_context->PSSetConstantBuffers(3, 1, &game_device_data.cb_taa_b2); + } + if (original_shader_hashes.Contains(shader_hashes_TAA)) { // Not thread safe? @@ -1198,6 +1204,7 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserv shader_hashes_UnprojectDepth.compute_shaders.emplace(std::stoul("223FB9DA", nullptr, 16)); // DH2 shader_hashes_UnprojectDepth.compute_shaders.emplace(std::stoul("74E15FB8", nullptr, 16)); // DH DOTO shader_hashes_SSAO.pixel_shaders.emplace(0x94445D2D); // DH2 + DH DOTO + shader_hashes_Downsample.pixel_shaders.emplace(0x42873B15); // All UI pixel shaders (these are all Shader Model 4.0, as opposed to the rest of the rendering using SM5.0) shader_hashes_UI.pixel_shaders = { std::stoul("6FE8114D", nullptr, 16), From f3f901ec9e0f44d892406b4d9f499be7186e64da Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Mon, 23 Feb 2026 01:50:00 +0100 Subject: [PATCH 08/11] Dishonored 2: Add option to disable lens distortion Removed lens distortion decompiled shader cause for whatever reason is always disabling lens distortion effect. --- .../LensDistortion_0x152A9E10.ps_5_0.hlsl | 101 ------------------ Source/Games/Dishonored 2/main.cpp | 22 ++++ 2 files changed, 22 insertions(+), 101 deletions(-) delete mode 100644 Shaders/Dishonored 2/LensDistortion_0x152A9E10.ps_5_0.hlsl diff --git a/Shaders/Dishonored 2/LensDistortion_0x152A9E10.ps_5_0.hlsl b/Shaders/Dishonored 2/LensDistortion_0x152A9E10.ps_5_0.hlsl deleted file mode 100644 index e64b0d7a..00000000 --- a/Shaders/Dishonored 2/LensDistortion_0x152A9E10.ps_5_0.hlsl +++ /dev/null @@ -1,101 +0,0 @@ -cbuffer PerInstanceCB : register(b2) -{ - float4 cb_positiontoviewtexture : packoffset(c0); - float4 cb_vectorfieldscales : packoffset(c1); -} - -cbuffer PerViewCB : register(b1) -{ - float4 cb_alwaystweak : packoffset(c0); - float4 cb_viewrandom : packoffset(c1); - float4x4 cb_viewprojectionmatrix : packoffset(c2); - float4x4 cb_viewmatrix : packoffset(c6); - float4 cb_subpixeloffset : packoffset(c10); - float4x4 cb_projectionmatrix : packoffset(c11); - float4x4 cb_previousviewprojectionmatrix : packoffset(c15); - float4x4 cb_previousviewmatrix : packoffset(c19); - float4x4 cb_previousprojectionmatrix : packoffset(c23); - float4 cb_mousecursorposition : packoffset(c27); - float4 cb_mousebuttonsdown : packoffset(c28); - float4 cb_jittervectors : packoffset(c29); - float4x4 cb_inverseviewprojectionmatrix : packoffset(c30); - float4x4 cb_inverseviewmatrix : packoffset(c34); - float4x4 cb_inverseprojectionmatrix : packoffset(c38); - float4 cb_globalviewinfos : packoffset(c42); - float3 cb_wscamforwarddir : packoffset(c43); - uint cb_alwaysone : packoffset(c43.w); - float3 cb_wscamupdir : packoffset(c44); - uint cb_usecompressedhdrbuffers : packoffset(c44.w); - float3 cb_wscampos : packoffset(c45); - float cb_time : packoffset(c45.w); - float3 cb_wscamleftdir : packoffset(c46); - float cb_systime : packoffset(c46.w); - float2 cb_jitterrelativetopreviousframe : packoffset(c47); - float2 cb_worldtime : packoffset(c47.z); - float2 cb_shadowmapatlasslicedimensions : packoffset(c48); - float2 cb_resolutionscale : packoffset(c48.z); - float2 cb_parallelshadowmapslicedimensions : packoffset(c49); - float cb_framenumber : packoffset(c49.z); - uint cb_alwayszero : packoffset(c49.w); -} - -SamplerState smp_bilinearclamp_s : register(s0); -SamplerState smp_bilinearmirror_s : register(s1); -Texture2D ro_motionvectors : register(t0); -Texture2D ro_viewcolormap : register(t1); - -#define cmp - - -void main( - float4 v0 : INTERP0, - out float4 o0 : SV_TARGET0) -{ - v0.xy = cb_subpixeloffset.xy + v0.xy; - v0.xy = cb_resolutionscale.xy * v0.xy; - o0.xyzw = ro_viewcolormap.Sample(smp_bilinearmirror_s, v0.xy).xyzw; - return; - float4 r0,r1,r2,r3,r4; - - r0.xy = cb_subpixeloffset.xy + v0.xy; - r0.xy = cb_resolutionscale.xy * r0.xy; - r0.xyzw = ro_motionvectors.SampleLevel(smp_bilinearclamp_s, r0.xy, 0).xyzw; - r0.zw = v0.xy + r0.zw; - r1.xy = r0.xy * cb_vectorfieldscales.xx + r0.zw; - r2.xyzw = cb_vectorfieldscales.xxxx * r0.xyxy; - r2.xyzw = r2.xyzw * float4(2,2,3,3) + r0.zwzw; - r0.xy = cb_resolutionscale.xy * r0.zw; - r2.xyzw = cb_resolutionscale.xyxy * r2.xyzw; - r0.zw = cb_resolutionscale.xy * r1.xy; - r1.xy = cmp(float2(0,0) < r0.zw); - r1.zw = cmp(r0.zw < float2(0,0)); - r1.xy = (int2)-r1.xy + (int2)r1.zw; - r1.xy = (int2)r1.xy; - r0.zw = r1.xy * r0.zw; - r1.xyzw = -cb_positiontoviewtexture.zwzw * float4(0.5,0.5,0.5,0.5) + cb_resolutionscale.xyxy; - r3.xy = min(r1.zw, r0.zw); - r0.zw = r3.xy * float2(2,2) + -r0.zw; - r3.xyzw = ro_viewcolormap.Sample(smp_bilinearmirror_s, r0.zw).xyzw; - r0.zw = cmp(float2(0,0) < r0.xy); - r4.xy = cmp(r0.xy < float2(0,0)); - r0.zw = (int2)-r0.zw + (int2)r4.xy; - r0.zw = (int2)r0.zw; - r0.xy = r0.xy * r0.zw; - r0.zw = min(r0.xy, r1.zw); - r0.xy = r0.zw * float2(2,2) + -r0.xy; - r0.xyzw = ro_viewcolormap.Sample(smp_bilinearmirror_s, r0.xy).xyzw; - r0.xyzw = r0.xyzw + r3.xyzw; - r3.xyzw = cmp(float4(0,0,0,0) < r2.xyzw); - r4.xyzw = cmp(r2.xyzw < float4(0,0,0,0)); - r3.xyzw = (int4)-r3.xyzw + (int4)r4.xyzw; - r3.xyzw = (int4)r3.xyzw; - r2.xyzw = r3.xyzw * r2.xyzw; - r1.xyzw = min(r2.xyzw, r1.xyzw); - r1.xyzw = r1.xyzw * float4(2,2,2,2) + -r2.xyzw; - r2.xyzw = ro_viewcolormap.Sample(smp_bilinearmirror_s, r1.xy).xyzw; - r1.xyzw = ro_viewcolormap.Sample(smp_bilinearmirror_s, r1.zw).xyzw; - r0.xyzw = r2.xyzw + r0.xyzw; - r0.xyzw = r0.xyzw + r1.xyzw; - r0.xyzw = float4(0.25,0.25,0.25,0.25) * r0.xyzw; - o0.w = saturate(r0.w); - o0.xyz = r0.xyz; -} \ No newline at end of file diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index f0105791..51af9382 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -57,11 +57,14 @@ namespace ShaderHashesList shader_hashes_UnprojectDepth; ShaderHashesList shader_hashes_SSAO; ShaderHashesList shader_hashes_Downsample; + ShaderHashesList shader_hashes_LensDistortion; // XeGTAO constexpr size_t XE_GTAO_DEPTH_MIP_LEVELS = 5; bool g_xegtao_enable = true; + bool g_disable_lens_distortion; + #if DEVELOPMENT std::thread::id global_cbuffer_thread_id; #endif @@ -559,6 +562,18 @@ class Dishonored2 final : public Game if (original_shader_hashes.Contains(shader_hashes_Downsample)) { native_device_context->PSSetConstantBuffers(3, 1, &game_device_data.cb_taa_b2); + + return DrawOrDispatchOverrideType::None; + } + + if (original_shader_hashes.Contains(shader_hashes_LensDistortion)) + { + if (g_disable_lens_distortion) + { + return DrawOrDispatchOverrideType::Skip; + } + + return DrawOrDispatchOverrideType::None; } if (original_shader_hashes.Contains(shader_hashes_TAA)) @@ -1068,6 +1083,7 @@ class Dishonored2 final : public Game reshade::api::effect_runtime* runtime = nullptr; reshade::get_config_value(runtime, NAME, "XeGTAOEnable", g_xegtao_enable); + reshade::get_config_value(runtime, NAME, "DisableLensDistortion", g_disable_lens_distortion); } void DrawImGuiSettings(DeviceData& device_data) override @@ -1082,6 +1098,11 @@ class Dishonored2 final : public Game { ImGui::SetTooltip("Replaces SSAO if enabled, HBAO+ has to be disabled in game."); } + + if (ImGui::Checkbox("Disable Lens Distortion", &g_disable_lens_distortion)) + { + reshade::set_config_value(runtime, NAME, "DisableLensDistortion", g_disable_lens_distortion); + } } void PrintImGuiAbout() override @@ -1205,6 +1226,7 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserv shader_hashes_UnprojectDepth.compute_shaders.emplace(std::stoul("74E15FB8", nullptr, 16)); // DH DOTO shader_hashes_SSAO.pixel_shaders.emplace(0x94445D2D); // DH2 + DH DOTO shader_hashes_Downsample.pixel_shaders.emplace(0x42873B15); + shader_hashes_LensDistortion.pixel_shaders.emplace(0x152A9E10); // All UI pixel shaders (these are all Shader Model 4.0, as opposed to the rest of the rendering using SM5.0) shader_hashes_UI.pixel_shaders = { std::stoul("6FE8114D", nullptr, 16), From d77a09597b2a132bcb0b4d8c772c734985284c95 Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Mon, 2 Mar 2026 00:47:21 +0100 Subject: [PATCH 09/11] Dishonored 2: Use auto exposure for DLSS --- Shaders/Dishonored 2/Luma_Exposure.hlsl | 38 --------------------- Source/Games/Dishonored 2/main.cpp | 45 ++----------------------- 2 files changed, 3 insertions(+), 80 deletions(-) delete mode 100644 Shaders/Dishonored 2/Luma_Exposure.hlsl diff --git a/Shaders/Dishonored 2/Luma_Exposure.hlsl b/Shaders/Dishonored 2/Luma_Exposure.hlsl deleted file mode 100644 index 95085de1..00000000 --- a/Shaders/Dishonored 2/Luma_Exposure.hlsl +++ /dev/null @@ -1,38 +0,0 @@ -struct postfx_luminance_autoexposure_t -{ - float EngineLuminanceFactor; // Offset: 0 - float LuminanceFactor; // Offset: 4 - float MinLuminanceLDR; // Offset: 8 - float MaxLuminanceLDR; // Offset: 12 - float MiddleGreyLuminanceLDR; // Offset: 16 - float EV; // Offset: 20 - float Fstop; // Offset: 24 - uint PeakHistogramValue; // Offset: 28 -}; - -cbuffer PerInstanceCB : register(b0) -{ - float4 cb_positiontoviewtexture : packoffset(c0); - float4 cb_taatexsize : packoffset(c1); - float4 cb_taaditherandviewportsize : packoffset(c2); - float4 cb_postfx_tonemapping_tonemappingparms : packoffset(c3); - float4 cb_postfx_tonemapping_tonemappingcoeffsinverse1 : packoffset(c4); - float4 cb_postfx_tonemapping_tonemappingcoeffsinverse0 : packoffset(c5); - float4 cb_postfx_tonemapping_tonemappingcoeffs1 : packoffset(c6); - float4 cb_postfx_tonemapping_tonemappingcoeffs0 : packoffset(c7); - uint2 cb_postfx_luminance_exposureindex : packoffset(c8); - float2 cb_prevresolutionscale : packoffset(c8.z); - float cb_env_tonemapping_white_level : packoffset(c9); - float cb_view_white_level : packoffset(c9.y); - float cb_taaamount : packoffset(c9.z); - float cb_postfx_luminance_customevbias : packoffset(c9.w); -} - -StructuredBuffer ro_postfx_luminance_buffautoexposure : register(t0); -RWTexture2D uav : register(u0); - -[numthreads(1, 1, 1)] -void main(uint3 dtid : SV_DispatchThreadID) -{ - uav[uint2(0,0)] = ro_postfx_luminance_buffautoexposure[cb_postfx_luminance_exposureindex.y].EV; -} \ No newline at end of file diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index 51af9382..0ca015f6 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -25,7 +25,7 @@ struct CBPerViewGlobals Matrix44F cb_previousprojectionmatrix; float4 cb_mousecursorposition; float4 cb_mousebuttonsdown; - // xy and the jitter offsets in uv space (y is flipped), zw might be the same in another space or the ones from the previous frame + // Jitters in UV space (not Halton, R2, or Sobol. Custom sequence?). xy current frame, zw previous frame. float4 cb_jittervectors; Matrix44F cb_inverseviewprojectionmatrix; Matrix44F cb_inverseviewmatrix; @@ -102,11 +102,8 @@ struct GameDeviceDataDishonored2 final : public GameDeviceData com_ptr sr_source_color; com_ptr sr_motion_vectors; //com_ptr sr_output_color_2; //TODOFT: delete this and related code - ComPtr sr_exposure; - // We need these to get exposure. ComPtr cb_taa_b2; - ComPtr srv_postfx_luminance_autoexposure; // Game state com_ptr depth_buffer; @@ -161,7 +158,6 @@ class Dishonored2 final : public Game native_shaders_definitions.emplace(CompileTimeStringHash("DS2 XeGTAO Prefilter Depths CS"), ShaderDefinition{ "Luma_XeGTAO", reshade::api::pipeline_subobject_type::compute_shader, nullptr, "prefilter_depths16x16_cs" }); native_shaders_definitions.emplace(CompileTimeStringHash("DS2 XeGTAO Main Pass PS"), ShaderDefinition{ "Luma_XeGTAO", reshade::api::pipeline_subobject_type::pixel_shader, nullptr, "main_pass_ps" }); - native_shaders_definitions.emplace(CompileTimeStringHash("DS2 Exposure CS"), ShaderDefinition{ "Luma_Exposure", reshade::api::pipeline_subobject_type::compute_shader }); } // This needs to be overridden with your own "GameDeviceData" sub-class (destruction is automatically handled) @@ -589,7 +585,6 @@ class Dishonored2 final : public Game if (device_data.sr_type != SR::Type::None && !device_data.sr_suppressed && original_shader_hashes.Contains(shader_hashes_TAA)) { native_device_context->CSGetConstantBuffers(2, 1, game_device_data.cb_taa_b2.put()); - native_device_context->CSGetShaderResources(3, 1, game_device_data.srv_postfx_luminance_autoexposure.put()); // TODO: Clean up all this, I think game will always use deferred rendering, so most of this is not needed. assert(native_device_context->GetType() == D3D11_DEVICE_CONTEXT_DEFERRED); @@ -953,41 +948,6 @@ class Dishonored2 final : public Game // Do "delayed" DLSS: - // First we get exposure to 2D texture 1x1. - // - - ComPtr native_device; - native_device_context->GetDevice(native_device.put()); - - // Create RTs and views. - if (!game_device_data.sr_exposure) { - D3D11_TEXTURE2D_DESC tex_desc = {}; - tex_desc.Width = 1; - tex_desc.Height = 1; - tex_desc.MipLevels = 1; - tex_desc.ArraySize = 1; - tex_desc.Format = DXGI_FORMAT_R32_FLOAT; - tex_desc.SampleDesc.Count = 1; - tex_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS; - ensure(native_device->CreateTexture2D(&tex_desc, nullptr, game_device_data.sr_exposure.put()), >= 0); - } - ComPtr uav; - ensure(native_device->CreateUnorderedAccessView(game_device_data.sr_exposure.get(), nullptr, uav.put()), >= 0); - - // Bindings. - native_device_context->CSSetUnorderedAccessViews(0, 1, &uav, nullptr); - native_device_context->CSSetShader(device_data.native_compute_shaders.at(CompileTimeStringHash("DS2 Exposure CS")).get(), nullptr, 0); - native_device_context->CSSetConstantBuffers(0, 1, &game_device_data.cb_taa_b2); - native_device_context->CSSetShaderResources(0, 1, &game_device_data.srv_postfx_luminance_autoexposure); - - native_device_context->Dispatch(1, 1, 1); - - // Ubind UAV. - ID3D11UnorderedAccessView* uav_null = nullptr; - native_device_context->CSSetUnorderedAccessViews(0, 1, &uav_null, nullptr); - - // - DrawStateStack draw_state_stack; DrawStateStack compute_state_stack; draw_state_stack.Cache(native_device_context.get(), device_data.uav_max_count); @@ -1007,6 +967,7 @@ class Dishonored2 final : public Game settings_data.inverted_depth = true; settings_data.mvs_jittered = false; settings_data.render_preset = dlss_render_preset; + settings_data.auto_exposure = true; sr_implementations[device_data.sr_type]->UpdateSettings(sr_instance_data, native_device_context.get(), settings_data); bool reset_dlss = device_data.force_reset_sr; @@ -1021,7 +982,7 @@ class Dishonored2 final : public Game draw_data.output_color = device_data.sr_output_color.get(); draw_data.motion_vectors = game_device_data.sr_motion_vectors.get(); draw_data.depth_buffer = game_device_data.depth_buffer.get(); - draw_data.exposure = game_device_data.sr_exposure.get(); + draw_data.exposure = nullptr; draw_data.pre_exposure = dlss_pre_exposure; draw_data.jitter_x = projection_jitters.x; draw_data.jitter_y = projection_jitters.y; From 5c5126f480f85b0c4f956235cdd96c4d6d5945d1 Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Mon, 2 Mar 2026 21:29:19 +0100 Subject: [PATCH 10/11] Dishonored 2: Correct inputs to DLSS. --- Source/Games/Dishonored 2/main.cpp | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index 0ca015f6..4dbd912a 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -957,6 +957,9 @@ class Dishonored2 final : public Game ASSERT_ONCE(sr_instance_data); std::array dlss_render_resolution = FindClosestIntegerResolutionForAspectRatio((double)device_data.output_resolution.x * (double)device_data.sr_render_resolution_scale, (double)device_data.output_resolution.y * (double)device_data.sr_render_resolution_scale, (double)device_data.output_resolution.x / (double)device_data.output_resolution.y); + uint32_t render_width_dlss = std::lrintf(device_data.render_resolution.x); + uint32_t render_height_dlss = std::lrintf(device_data.render_resolution.y); + SR::SettingsData settings_data; settings_data.output_width = device_data.output_resolution.x; settings_data.output_height = device_data.output_resolution.y; @@ -968,14 +971,17 @@ class Dishonored2 final : public Game settings_data.mvs_jittered = false; settings_data.render_preset = dlss_render_preset; settings_data.auto_exposure = true; + + // MVs are in UV space so we need to scale them to screen space for DLSS, + // aslo we need to flip sighn on both for DLSS. + settings_data.mvs_x_scale = -(float)render_width_dlss; + settings_data.mvs_y_scale = -(float)render_height_dlss; + sr_implementations[device_data.sr_type]->UpdateSettings(sr_instance_data, native_device_context.get(), settings_data); bool reset_dlss = device_data.force_reset_sr; device_data.force_reset_sr = false; - uint32_t render_width_dlss = std::lrintf(device_data.render_resolution.x); - uint32_t render_height_dlss = std::lrintf(device_data.render_resolution.y); - float dlss_pre_exposure = 1.0; SR::SuperResolutionImpl::DrawData draw_data; draw_data.source_color = game_device_data.sr_source_color.get(); @@ -984,8 +990,12 @@ class Dishonored2 final : public Game draw_data.depth_buffer = game_device_data.depth_buffer.get(); draw_data.exposure = nullptr; draw_data.pre_exposure = dlss_pre_exposure; - draw_data.jitter_x = projection_jitters.x; - draw_data.jitter_y = projection_jitters.y; + + // We need to swap jitters. Are they originally swapped or it's just DLSS things? + // Jitters are in UV offsets so we need to scale them to pixel offsets for DLSS. + draw_data.jitter_x = cb_per_view_global.cb_jittervectors.y * (float)render_height_dlss; + draw_data.jitter_y = cb_per_view_global.cb_jittervectors.x * (float)render_width_dlss; + draw_data.reset = reset_dlss; draw_data.render_width = render_width_dlss; draw_data.render_height = render_height_dlss; From 31176feee9d5a3b76540ff001e85e7857928992d Mon Sep 17 00:00:00 2001 From: garamond13 <98652255+garamond13@users.noreply.github.com> Date: Fri, 6 Mar 2026 16:35:47 +0100 Subject: [PATCH 11/11] Dishonored 2: Properly disable lens distortion. --- ...ndLensDistortionMVs_0xC97890C8.ps_5_0.hlsl | 157 ++++++++++++++++++ ...ndLensDistortionMVs_0xE908E905.ps_5_0.hlsl | 113 +++++++++++++ Source/Games/Dishonored 2/main.cpp | 23 +-- 3 files changed, 272 insertions(+), 21 deletions(-) create mode 100644 Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xC97890C8.ps_5_0.hlsl create mode 100644 Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xE908E905.ps_5_0.hlsl diff --git a/Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xC97890C8.ps_5_0.hlsl b/Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xC97890C8.ps_5_0.hlsl new file mode 100644 index 00000000..d4b6a4fa --- /dev/null +++ b/Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xC97890C8.ps_5_0.hlsl @@ -0,0 +1,157 @@ +cbuffer PerInstanceCB : register(b2) +{ + float4 cb_fsdisto_lensstrength : packoffset(c0); + float4 cb_viewport : packoffset(c1); + float4 cb_positiontoviewtexture : packoffset(c2); + float4 cb_fsdisto_wobblestrength : packoffset(c3); + float4 cb_fsdisto_wobblespeed : packoffset(c4); + float4 cb_fsdisto_wobblelowbound : packoffset(c5); + float4 cb_fsdisto_wobblehighbound : packoffset(c6); + float4 cb_fsdisto_sandstorm_startvalue : packoffset(c7); + float4 cb_fsdisto_sandstorm_endvalue : packoffset(c8); + float4 cb_fsdisto_radialdistostrength : packoffset(c9); + float4 cb_fsdisto_radialblurstrength : packoffset(c10); + float4 cb_fsdisto_radialblurdeadzone : packoffset(c11); + float3 cb_fsdisto_sandstorm_worldwind : packoffset(c12); + float cb_fsdisto_camerablur_enddepth : packoffset(c12.w); + float2 cb_localtime : packoffset(c13); + float cb_fsdisto_sandstorm_startdepth : packoffset(c13.z); + float cb_fsdisto_sandstorm_enddepth : packoffset(c13.w); + float cb_fsdisto_sandstorm_deadzone : packoffset(c14); + float cb_fsdisto_camerablur_strength : packoffset(c14.y); + float cb_fsdisto_camerablur_startdepth : packoffset(c14.z); +} + +cbuffer PerViewCB : register(b1) +{ + float4 cb_alwaystweak : packoffset(c0); + float4 cb_viewrandom : packoffset(c1); + float4x4 cb_viewprojectionmatrix : packoffset(c2); + float4x4 cb_viewmatrix : packoffset(c6); + float4 cb_subpixeloffset : packoffset(c10); + float4x4 cb_projectionmatrix : packoffset(c11); + float4x4 cb_previousviewprojectionmatrix : packoffset(c15); + float4x4 cb_previousviewmatrix : packoffset(c19); + float4x4 cb_previousprojectionmatrix : packoffset(c23); + float4 cb_mousecursorposition : packoffset(c27); + float4 cb_mousebuttonsdown : packoffset(c28); + float4 cb_jittervectors : packoffset(c29); + float4x4 cb_inverseviewprojectionmatrix : packoffset(c30); + float4x4 cb_inverseviewmatrix : packoffset(c34); + float4x4 cb_inverseprojectionmatrix : packoffset(c38); + float4 cb_globalviewinfos : packoffset(c42); + float3 cb_wscamforwarddir : packoffset(c43); + uint cb_alwaysone : packoffset(c43.w); + float3 cb_wscamupdir : packoffset(c44); + uint cb_usecompressedhdrbuffers : packoffset(c44.w); + float3 cb_wscampos : packoffset(c45); + float cb_time : packoffset(c45.w); + float3 cb_wscamleftdir : packoffset(c46); + float cb_systime : packoffset(c46.w); + float2 cb_jitterrelativetopreviousframe : packoffset(c47); + float2 cb_worldtime : packoffset(c47.z); + float2 cb_shadowmapatlasslicedimensions : packoffset(c48); + float2 cb_resolutionscale : packoffset(c48.z); + float2 cb_parallelshadowmapslicedimensions : packoffset(c49); + float cb_framenumber : packoffset(c49.z); + uint cb_alwayszero : packoffset(c49.w); +} + +SamplerState smp_linearclamp_s : register(s0); +Texture2D ro_fx_depthfull : register(t0); + +#ifndef DISABLE_LENS_DISTORTION +#define DISABLE_LENS_DISTORTION 0 +#endif + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_POSITION0, + out float4 o0 : SV_TARGET0) +{ + float4 r0,r1,r2,r3; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyz = float3(1,1,1) / cb_positiontoviewtexture.zzw; + r0.x = cb_positiontoviewtexture.w * r0.x; + r0.w = cb_resolutionscale.x / cb_resolutionscale.y; + r0.x = r0.x / r0.w; + r0.x = 1.77777779 / r0.x; + r1.xy = cb_resolutionscale.xy * cb_positiontoviewtexture.zw; + r0.xw = r1.xy * r0.xx; + r0.x = max(r0.x, r0.w); + r0.w = 450 * r0.x; + r0.yz = -r0.yz * float2(0.5,0.5) + v0.xy; + r0.yz = r0.yz / cb_resolutionscale.xy; + r1.xy = cb_positiontoviewtexture.zw * v0.xy; + r1.xy = cb_resolutionscale.xy * r1.xy; + r1.x = ro_fx_depthfull.SampleLevel(smp_linearclamp_s, r1.xy, 0).x; + r1.y = cb_inverseprojectionmatrix._m32 * r1.x + cb_inverseprojectionmatrix._m33; + r1.y = -cb_inverseprojectionmatrix._m23 / r1.y; + r1.zw = -cb_viewport.xy + v0.xy; + r2.xy = float2(0.5,0.5) * cb_viewport.zw; + r1.zw = -cb_viewport.zw * float2(0.5,0.5) + r1.zw; + r1.zw = r1.zw / r2.xy; + r2.xy = float2(1,-1) * r1.zw; + r3.xyzw = cb_inverseviewprojectionmatrix._m01_m11_m21_m31 * r2.yyyy; + r2.xyzw = cb_inverseviewprojectionmatrix._m00_m10_m20_m30 * r2.xxxx + r3.xyzw; + r2.xyzw = cb_inverseviewprojectionmatrix._m02_m12_m22_m32 * r1.xxxx + r2.xyzw; + r2.xyzw = cb_inverseviewprojectionmatrix._m03_m13_m23_m33 + r2.xyzw; + r2.xyzw = r2.xyzw / r2.wwww; + r3.xyz = cb_previousviewprojectionmatrix._m01_m11_m31 * r2.yyy; + r3.xyz = cb_previousviewprojectionmatrix._m00_m10_m30 * r2.xxx + r3.xyz; + r2.xyz = cb_previousviewprojectionmatrix._m02_m12_m32 * r2.zzz + r3.xyz; + r2.xyz = cb_previousviewprojectionmatrix._m03_m13_m33 * r2.www + r2.xyz; + r2.xy = r2.xy / abs(r2.zz); + r1.xz = r1.zw * float2(1,-1) + -r2.xy; + r1.xz = float2(-0.5,0.5) * r1.xz; + r1.xz = max(float2(-1,-1), r1.xz); + r1.xz = min(float2(1,1), r1.xz); + r1.w = -cb_fsdisto_camerablur_startdepth + cb_fsdisto_camerablur_enddepth; + r1.y = -cb_fsdisto_camerablur_startdepth + r1.y; + r1.y = saturate(r1.y / r1.w); + r2.xy = cb_fsdisto_camerablur_strength * cb_positiontoviewtexture.zw; + r1.yw = r2.xy * r1.yy; + r1.yw = cb_resolutionscale.xy * r1.yw; + r1.xy = r1.xz * r1.yw; + r1.zw = cb_positiontoviewtexture.zw * r0.yz; + r1.zw = cb_resolutionscale.xy * r1.zw; + r2.x = dot(r1.zw, r1.zw); + r2.x = rsqrt(r2.x); + r1.zw = r2.xx * r1.zw; + r1.zw = -r1.zw * r0.xx; + r0.w = cb_fsdisto_radialblurdeadzone.x / r0.w; + r0.y = dot(r0.yz, r0.yz); + r0.y = sqrt(r0.y); + r0.y = r0.y + -r0.w; + r0.z = 1 / r0.x; + r0.y = max(0, r0.y); + r0.y = min(r0.y, r0.z); + r0.yz = r1.zw * r0.yy; + r0.xy = r0.yz * r0.xx; + r0.xy = cb_resolutionscale.xy * r0.xy; + + #if DISABLE_LENS_DISTORTION + r0.zw = 0.0; + #else + r0.zw = cb_fsdisto_radialblurstrength.xx * r0.xy; + #endif + + r1.xy = r1.xy * cb_resolutionscale.xy + r0.zw; + + #if DISABLE_LENS_DISTORTION + r1.zw = 0.0; + #else + r1.zw = cb_fsdisto_radialdistostrength.xx * r0.xy; + #endif + + r0.x = dot(r1.xyzw, float4(1,1,1,1)); + r0.x = cmp(abs(r0.x) == 0.000000); + if (r0.x != 0) discard; + o0.xyzw = r1.xyzw; + return; +} \ No newline at end of file diff --git a/Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xE908E905.ps_5_0.hlsl b/Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xE908E905.ps_5_0.hlsl new file mode 100644 index 00000000..404fcbe3 --- /dev/null +++ b/Shaders/Dishonored 2/MotionBlurAndLensDistortionMVs_0xE908E905.ps_5_0.hlsl @@ -0,0 +1,113 @@ +cbuffer PerInstanceCB : register(b2) +{ + float4 cb_fsdisto_lensstrength : packoffset(c0); + float4 cb_positiontoviewtexture : packoffset(c1); + float4 cb_fsdisto_wobblestrength : packoffset(c2); + float4 cb_fsdisto_wobblespeed : packoffset(c3); + float4 cb_fsdisto_wobblelowbound : packoffset(c4); + float4 cb_fsdisto_wobblehighbound : packoffset(c5); + float4 cb_fsdisto_sandstorm_startvalue : packoffset(c6); + float4 cb_fsdisto_sandstorm_endvalue : packoffset(c7); + float4 cb_fsdisto_radialdistostrength : packoffset(c8); + float4 cb_fsdisto_radialblurstrength : packoffset(c9); + float4 cb_fsdisto_radialblurdeadzone : packoffset(c10); + float3 cb_fsdisto_sandstorm_worldwind : packoffset(c11); + float cb_fsdisto_sandstorm_deadzone : packoffset(c11.w); + float2 cb_localtime : packoffset(c12); + float cb_fsdisto_sandstorm_startdepth : packoffset(c12.z); + float cb_fsdisto_sandstorm_enddepth : packoffset(c12.w); +} + +cbuffer PerViewCB : register(b1) +{ + float4 cb_alwaystweak : packoffset(c0); + float4 cb_viewrandom : packoffset(c1); + float4x4 cb_viewprojectionmatrix : packoffset(c2); + float4x4 cb_viewmatrix : packoffset(c6); + float4 cb_subpixeloffset : packoffset(c10); + float4x4 cb_projectionmatrix : packoffset(c11); + float4x4 cb_previousviewprojectionmatrix : packoffset(c15); + float4x4 cb_previousviewmatrix : packoffset(c19); + float4x4 cb_previousprojectionmatrix : packoffset(c23); + float4 cb_mousecursorposition : packoffset(c27); + float4 cb_mousebuttonsdown : packoffset(c28); + float4 cb_jittervectors : packoffset(c29); + float4x4 cb_inverseviewprojectionmatrix : packoffset(c30); + float4x4 cb_inverseviewmatrix : packoffset(c34); + float4x4 cb_inverseprojectionmatrix : packoffset(c38); + float4 cb_globalviewinfos : packoffset(c42); + float3 cb_wscamforwarddir : packoffset(c43); + uint cb_alwaysone : packoffset(c43.w); + float3 cb_wscamupdir : packoffset(c44); + uint cb_usecompressedhdrbuffers : packoffset(c44.w); + float3 cb_wscampos : packoffset(c45); + float cb_time : packoffset(c45.w); + float3 cb_wscamleftdir : packoffset(c46); + float cb_systime : packoffset(c46.w); + float2 cb_jitterrelativetopreviousframe : packoffset(c47); + float2 cb_worldtime : packoffset(c47.z); + float2 cb_shadowmapatlasslicedimensions : packoffset(c48); + float2 cb_resolutionscale : packoffset(c48.z); + float2 cb_parallelshadowmapslicedimensions : packoffset(c49); + float cb_framenumber : packoffset(c49.z); + uint cb_alwayszero : packoffset(c49.w); +} + +#ifndef DISABLE_LENS_DISTORTION +#define DISABLE_LENS_DISTORTION 0 +#endif + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_POSITION0, + out float4 o0 : SV_TARGET0) +{ + float4 r0,r1; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyz = float3(1,1,1) / cb_positiontoviewtexture.zzw; + r0.x = cb_positiontoviewtexture.w * r0.x; + r0.w = cb_resolutionscale.x / cb_resolutionscale.y; + r0.x = r0.x / r0.w; + r0.x = 1.77777779 / r0.x; + r1.xy = cb_resolutionscale.xy * cb_positiontoviewtexture.zw; + r0.xw = r1.xy * r0.xx; + r0.x = max(r0.x, r0.w); + r0.w = 450 * r0.x; + r0.yz = -r0.yz * float2(0.5,0.5) + v0.xy; + r0.yz = r0.yz / cb_resolutionscale.xy; + r1.xy = cb_positiontoviewtexture.zw * r0.yz; + r1.xy = cb_resolutionscale.xy * r1.xy; + r1.z = dot(r1.xy, r1.xy); + r1.z = rsqrt(r1.z); + r1.xy = r1.xy * r1.zz; + r1.xy = -r1.xy * r0.xx; + r0.w = cb_fsdisto_radialblurdeadzone.x / r0.w; + r0.y = dot(r0.yz, r0.yz); + r0.y = sqrt(r0.y); + r0.y = r0.y + -r0.w; + r0.z = 1 / r0.x; + r0.y = max(0, r0.y); + r0.y = min(r0.y, r0.z); + r0.yz = r1.xy * r0.yy; + r0.xy = r0.yz * r0.xx; + r0.xy = cb_resolutionscale.xy * r0.xy; + + #if DISABLE_LENS_DISTORTION + r1.xy = 0.0; + r1.zw = 0.0; + #else + r1.xy = cb_fsdisto_radialblurstrength.xx * r0.xy; + r1.zw = cb_fsdisto_radialdistostrength.xx * r0.xy; + #endif + + r0.x = dot(r1.xyzw, float4(1,1,1,1)); + r0.x = cmp(abs(r0.x) == 0.000000); + if (r0.x != 0) discard; + o0.xyzw = r1.xyzw; + return; +} \ No newline at end of file diff --git a/Source/Games/Dishonored 2/main.cpp b/Source/Games/Dishonored 2/main.cpp index 4dbd912a..170a52ca 100644 --- a/Source/Games/Dishonored 2/main.cpp +++ b/Source/Games/Dishonored 2/main.cpp @@ -57,14 +57,11 @@ namespace ShaderHashesList shader_hashes_UnprojectDepth; ShaderHashesList shader_hashes_SSAO; ShaderHashesList shader_hashes_Downsample; - ShaderHashesList shader_hashes_LensDistortion; // XeGTAO constexpr size_t XE_GTAO_DEPTH_MIP_LEVELS = 5; bool g_xegtao_enable = true; - bool g_disable_lens_distortion; - #if DEVELOPMENT std::thread::id global_cbuffer_thread_id; #endif @@ -152,6 +149,7 @@ class Dishonored2 final : public Game std::vector game_shader_defines_data = { { "XE_GTAO_QUALITY", '2', true, false, "0 - Low\n1 - Medium\n2 - High\n3 - Very High\n4 - Ultra", 4 }, + { "DISABLE_LENS_DISTORTION", '0', true, false, "Disable lens distortion while running or ducked.", 1 } }; shader_defines_data.append_range(game_shader_defines_data); @@ -562,16 +560,6 @@ class Dishonored2 final : public Game return DrawOrDispatchOverrideType::None; } - if (original_shader_hashes.Contains(shader_hashes_LensDistortion)) - { - if (g_disable_lens_distortion) - { - return DrawOrDispatchOverrideType::Skip; - } - - return DrawOrDispatchOverrideType::None; - } - if (original_shader_hashes.Contains(shader_hashes_TAA)) { // Not thread safe? @@ -973,7 +961,7 @@ class Dishonored2 final : public Game settings_data.auto_exposure = true; // MVs are in UV space so we need to scale them to screen space for DLSS, - // aslo we need to flip sighn on both for DLSS. + // aslo we need to flip sign on both for DLSS. settings_data.mvs_x_scale = -(float)render_width_dlss; settings_data.mvs_y_scale = -(float)render_height_dlss; @@ -1054,7 +1042,6 @@ class Dishonored2 final : public Game reshade::api::effect_runtime* runtime = nullptr; reshade::get_config_value(runtime, NAME, "XeGTAOEnable", g_xegtao_enable); - reshade::get_config_value(runtime, NAME, "DisableLensDistortion", g_disable_lens_distortion); } void DrawImGuiSettings(DeviceData& device_data) override @@ -1069,11 +1056,6 @@ class Dishonored2 final : public Game { ImGui::SetTooltip("Replaces SSAO if enabled, HBAO+ has to be disabled in game."); } - - if (ImGui::Checkbox("Disable Lens Distortion", &g_disable_lens_distortion)) - { - reshade::set_config_value(runtime, NAME, "DisableLensDistortion", g_disable_lens_distortion); - } } void PrintImGuiAbout() override @@ -1197,7 +1179,6 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserv shader_hashes_UnprojectDepth.compute_shaders.emplace(std::stoul("74E15FB8", nullptr, 16)); // DH DOTO shader_hashes_SSAO.pixel_shaders.emplace(0x94445D2D); // DH2 + DH DOTO shader_hashes_Downsample.pixel_shaders.emplace(0x42873B15); - shader_hashes_LensDistortion.pixel_shaders.emplace(0x152A9E10); // All UI pixel shaders (these are all Shader Model 4.0, as opposed to the rest of the rendering using SM5.0) shader_hashes_UI.pixel_shaders = { std::stoul("6FE8114D", nullptr, 16),