feat: effect11 feature

CMakeLists.txt

@@ -90,6 +90,8 @@ find_package(unordered_dense CONFIG REQUIRED)
 find_package(efsw CONFIG REQUIRED)
 find_package(Tracy CONFIG REQUIRED)
 find_package(directx-headers CONFIG REQUIRED)
+find_package(effects11 CONFIG REQUIRED)
+
 add_subdirectory(${CMAKE_SOURCE_DIR}/cmake/Streamline)
 
 find_path(DETOURS_INCLUDE_DIRS "detours/detours.h")
@@ -142,6 +144,8 @@ target_link_libraries(
         d3d12.lib
         Microsoft::DirectX-Headers
         ${DETOURS_LIBRARY}
+        Microsoft::Effects11
+        windowsapp
 )
 
 # Some third-party libs (e.g. FFX backend) are built with /GL.

features/Cloud Shadows/Shaders/CloudShadows/CloudShadows.hlsli

@@ -4,11 +4,7 @@ namespace CloudShadows
 {
 	TextureCube<float> CloudShadowsTexture : register(t25);
 
-	// 2 km cloud altitude / 6371 km planet radius converted from metres
-	// to game units. The original 1.428e-2 is GAME_UNIT_TO_M (1.428f / 100),
-	// so dividing by GAME_UNIT_TO_M is the exact same value. Game.hlsli
-	// parenthesizes the macro, so the operator precedence is preserved.
-	const static float CloudHeight = (2e3f / GAME_UNIT_TO_M) * 0.25;
+	const static float CloudHeight = (2e3f / GAME_UNIT_TO_M);
 	const static float PlanetRadius = (6371e3f / GAME_UNIT_TO_M);
 	const static float RcpHPlusR = (1.0 / (CloudHeight + PlanetRadius));
 
@@ -27,6 +23,13 @@ namespace CloudShadows
 	{
 		float3 cloudSampleDir = GetCloudShadowSampleDir(worldPosition, SharedData::DirLightDirection.xyz).xyz;
 		float cloudCubeSample = CloudShadowsTexture.SampleLevel(textureSampler, cloudSampleDir, 0).x;
-		return lerp(1.0, 1.0 - cloudCubeSample, SharedData::cloudShadowsSettings.Opacity);
+		return saturate(1.0 - cloudCubeSample * SharedData::cloudShadowsSettings.Opacity);
+	}
+
+	float GetTrueCloudShadowMult(float3 worldPosition, SamplerState textureSampler)
+	{
+		float3 cloudSampleDir = GetCloudShadowSampleDir(worldPosition, SharedData::SunDirection.xyz).xyz;
+		float cloudCubeSample = CloudShadowsTexture.SampleLevel(textureSampler, cloudSampleDir, 0).x;
+		return 1.0 - cloudCubeSample;
 	}
 }

features/Dynamic Cubemaps/Shaders/Features/DynamicCubemaps.ini

@@ -1,5 +1,5 @@
 [Info]
-Version = 2-3-1
+Version = 2-4-0
 
 [Nexus]
 autoupload = false

features/Effect11/Shaders/Effect11/ApplyVolumetricRaysPS.hlsl

@@ -0,0 +1,42 @@
+#include "Common/SharedData.hlsli"
+
+#if defined(IBL)
+#	define IBL_DEFERRED
+#	include "IBL/IBL.hlsli"
+#endif
+
+Texture2D<float> BlurredShadowTexture : register(t0);
+
+struct VS_OUTPUT_POST
+{
+	float4 pos : SV_POSITION;
+	float2 txcoord0 : TEXCOORD0;
+};
+
+float4 main(VS_OUTPUT_POST input) : SV_Target0
+{
+	float2 uv = input.txcoord0;
+	uint eyeIndex = 0;
+
+	float volumetricShadow = BlurredShadowTexture.Load(int3(input.pos.xy, 0));
+
+	float depth = SharedData::GetDepth(uv);
+	float4 positionCS = float4(2 * float2(uv.x, -uv.y + 1) - 1, depth, 1);
+	float4 positionMS = mul(FrameBuffer::CameraViewProjInverse[eyeIndex], positionCS);
+	positionMS.xyz /= positionMS.w;
+
+	float3 viewDirection = normalize(positionMS.xyz);
+
+	float phase = dot(viewDirection, SharedData::SunDirection.xyz) * 0.5 + 0.5;
+	float3 lightColor = SharedData::SunColor.xyz * phase;
+
+#if defined(IBL)
+	float3 ibl = ImageBasedLighting::GetSkyIBL(float3(0, 0, -1));
+	ibl = lerp(dot(ibl, 1.0 / 3.0), ibl, 2.0);
+	lightColor += ibl * SharedData::enbSettings.VolumetricRaysSkyColorAmount;
+#endif
+
+	float3 volumetricColor = volumetricShadow * lightColor * SharedData::enbSettings.VolumetricRaysIntensity * SharedData::SunColor.w;
+
+	return float4(volumetricColor, 0);
+}

features/Effect11/Shaders/Effect11/ColorCorrectionCS.hlsl

@@ -0,0 +1,44 @@
+cbuffer ColorCorrectionParams : register(b0)
+{
+	float Brightness;
+	float GammaCurve;
+	uint FrameCount;
+};
+
+RWTexture2D<float4> OutputTexture : register(u0);
+
+uint3 pcg3d(uint3 v)
+{
+	v = v * 1664525u + 1013904223u;
+	v.x += v.y * v.z;
+	v.y += v.z * v.x;
+	v.z += v.x * v.y;
+	v ^= v >> 16u;
+	v.x += v.y * v.z;
+	v.y += v.z * v.x;
+	v.z += v.x * v.y;
+	return v;
+}
+
+float3 TriDither(float2 screenPos, uint frameCount)
+{
+	uint3 seed1 = uint3(screenPos, frameCount);
+	uint3 seed2 = uint3(screenPos, frameCount + 4729u);
+	return (pcg3d(seed1) - pcg3d(seed2)) / float(0xFFFFFFFFu);
+}
+
+[numthreads(8, 8, 1)] void main(uint3 id
+	: SV_DispatchThreadID)
+{
+	uint width, height;
+	OutputTexture.GetDimensions(width, height);
+	if (id.x >= width || id.y >= height) {
+		return;
+	}
+
+	float4 color = OutputTexture[id.xy];
+	color.rgb = pow(abs(color.rgb), GammaCurve);
+	color.rgb *= Brightness;
+	color.rgb += TriDither(float2(id.xy), FrameCount) / 1023.0;
+	OutputTexture[id.xy] = color;
+}

features/Effect11/Shaders/Effect11/CopyPS.hlsl

@@ -0,0 +1,39 @@
+Texture2D SourceTexture : register(t0);
+
+cbuffer DitherParams : register(b0)
+{
+	uint FrameCount;
+};
+
+struct PS_INPUT
+{
+	float4 pos : SV_POSITION;
+	float2 txcoord0 : TEXCOORD0;
+};
+
+uint3 pcg3d(uint3 v)
+{
+	v = v * 1664525u + 1013904223u;
+	v.x += v.y * v.z;
+	v.y += v.z * v.x;
+	v.z += v.x * v.y;
+	v ^= v >> 16u;
+	v.x += v.y * v.z;
+	v.y += v.z * v.x;
+	v.z += v.x * v.y;
+	return v;
+}
+
+float3 TriDither(float2 screenPos, uint frameCount)
+{
+	uint3 seed1 = uint3(screenPos, frameCount);
+	uint3 seed2 = uint3(screenPos, frameCount + 4729u);
+	return (pcg3d(seed1) - pcg3d(seed2)) / float(0xFFFFFFFFu);
+}
+
+float4 main(PS_INPUT input) : SV_TARGET
+{
+	float3 color = SourceTexture.Load(int3(input.pos.xy, 0)).rgb;
+	color += TriDither(input.pos.xy, FrameCount) / 255.0;
+	return float4(color, 1.0);
+}

features/Effect11/Shaders/Effect11/DownsamplePS.hlsl

@@ -0,0 +1,13 @@
+Texture2D<float4> SourceTexture : register(t0);
+SamplerState LinearSampler : register(s0);
+
+struct PS_INPUT
+{
+	float4 pos : SV_POSITION;
+	float2 txcoord0 : TEXCOORD0;
+};
+
+float4 main(PS_INPUT input) : SV_Target
+{
+	return SourceTexture.SampleLevel(LinearSampler, input.txcoord0.xy, 0);
+}

features/Effect11/Shaders/Effect11/KawaseBlurPS.hlsl

@@ -0,0 +1,22 @@
+Texture2D<float4> SourceTexture : register(t0);
+SamplerState LinearSampler : register(s0);
+
+struct PS_INPUT
+{
+	float4 pos : SV_POSITION;
+	float2 txcoord0 : TEXCOORD0;
+};
+
+float4 main(PS_INPUT input) : SV_Target
+{
+	float2 texelSize = 1.0 / 1024.0;
+	float2 o = texelSize * 0.5;
+
+	float4 sum = 0.0;
+	sum += SourceTexture.SampleLevel(LinearSampler, input.txcoord0.xy + float2(-o.x, -o.y), 0);
+	sum += SourceTexture.SampleLevel(LinearSampler, input.txcoord0.xy + float2( o.x, -o.y), 0);
+	sum += SourceTexture.SampleLevel(LinearSampler, input.txcoord0.xy + float2(-o.x,  o.y), 0);
+	sum += SourceTexture.SampleLevel(LinearSampler, input.txcoord0.xy + float2( o.x,  o.y), 0);
+
+	return sum * 0.25;
+}

features/Effect11/Shaders/Effect11/QuadVS.hlsl

@@ -0,0 +1,19 @@
+struct VS_INPUT_POST
+{
+	float3 pos : POSITION;
+	float2 txcoord : TEXCOORD0;
+};
+
+struct VS_OUTPUT_POST
+{
+	float4 pos : SV_POSITION;
+	float2 txcoord0 : TEXCOORD0;
+};
+
+VS_OUTPUT_POST main(VS_INPUT_POST IN)
+{
+	VS_OUTPUT_POST OUT;
+	OUT.pos = float4(IN.pos, 1.0);
+	OUT.txcoord0 = IN.txcoord;
+	return OUT;
+}

features/Effect11/Shaders/Effect11/RaymarchVolumetricRaysPS.hlsl

@@ -0,0 +1,55 @@
+#include "Common/FrameBuffer.hlsli"
+#include "Common/Random.hlsli"
+#include "Common/SharedData.hlsli"
+
+#define LinearSampler defaultSampler
+SamplerState defaultSampler : register(s0);
+
+#include "Common/ShadowSampling.hlsli"
+
+struct VS_OUTPUT_POST
+{
+	float4 pos : SV_POSITION;
+	float2 txcoord0 : TEXCOORD0;
+};
+
+float main(VS_OUTPUT_POST input) : SV_Target0
+{
+	float2 uv = input.txcoord0;
+	uint eyeIndex = 0;
+
+	float depth = SharedData::GetDepth(uv);
+	float4 positionCS = float4(2 * float2(uv.x, -uv.y + 1) - 1, depth, 1);
+	float4 positionMS = mul(FrameBuffer::CameraViewProjInverse[eyeIndex], positionCS);
+	positionMS.xyz /= positionMS.w;
+
+	float extinction = SharedData::enbSettings.VolumetricRaysExtinction;
+	float totalRayLength = length(positionMS.xyz);
+
+	const uint sampleCount = 16;
+	float noise = Random::InterleavedGradientNoise(input.pos.xy, SharedData::FrameCount);
+	float3 cameraOffset = FrameBuffer::CameraPosAdjust[eyeIndex].xyz;
+
+	float scattering = 0.0;
+	float transmittance = 1.0;
+
+	for (uint i = 0; i < sampleCount; i++) {
+		float t0 = float(i) / float(sampleCount);
+		float t1 = float(i + 1) / float(sampleCount);
+
+		t0 *= t0;
+		t1 *= t1;
+
+		float t = lerp(t0, t1, noise);
+		float stepLength = (t1 - t0) * totalRayLength;
+
+		float3 samplePos = positionMS.xyz * t;
+		float shadow = ShadowSampling::GetTrueWorldShadow(samplePos, cameraOffset, eyeIndex);
+
+		float stepTransmittance = exp(-extinction * stepLength);
+		scattering += shadow * (1.0 - stepTransmittance) * transmittance;
+		transmittance *= stepTransmittance;
+	}
+
+	return scattering;
+}