perf(ssgi): optimize

features/Skylighting/Shaders/Skylighting/Skylighting.hlsli

@@ -8,7 +8,7 @@
 
 namespace Skylighting
 {
-#ifdef PSHADER
+#if defined(PSHADER)
 	Texture3D<sh2> SkylightingProbeArray : register(t50);
 	Texture2DArray<float3> stbn_vec3_2Dx1D_128x128x64 : register(t51);
 #endif
@@ -35,6 +35,26 @@ namespace Skylighting
 		return lerp(params.MinSpecularVisibility, 1.0, saturate(visibility));
 	}
 
+#if defined(PSHADER)
+	void applySkylighting(inout float3 diffuseColor, inout float3 directionalAmbientColor, float skylightingDiffuse)
+	{
+		float maxScale = 1.0;
+		if (directionalAmbientColor.x > 0.0)
+			maxScale = min(maxScale, diffuseColor.x / directionalAmbientColor.x);
+		if (directionalAmbientColor.y > 0.0)
+			maxScale = min(maxScale, diffuseColor.y / directionalAmbientColor.y);
+		if (directionalAmbientColor.z > 0.0)
+			maxScale = min(maxScale, diffuseColor.z / directionalAmbientColor.z);
+		directionalAmbientColor *= maxScale;
+
+		diffuseColor = max(0.0, diffuseColor - directionalAmbientColor);
+
+		directionalAmbientColor = Color::LinearToGamma(Color::GammaToLinear(directionalAmbientColor) * skylightingDiffuse);
+
+		diffuseColor += directionalAmbientColor;
+	}
+#endif
+
 	sh2 sample(SharedData::SkylightingSettings params, Texture3D<sh2> probeArray, Texture2DArray<float3> blueNoise, float2 screenPosition, float3 positionMS, float3 normalWS)
 	{
 		const static sh2 unitSH = float4(sqrt(4 * Math::PI), 0, 0, 0);

package/Shaders/DeferredCompositeCS.hlsl

@@ -10,7 +10,7 @@
 Texture2D<float3> SpecularTexture : register(t0);
 Texture2D<unorm float3> AlbedoTexture : register(t1);
 Texture2D<unorm float3> NormalRoughnessTexture : register(t2);
-Texture2D<unorm float3> MasksTexture : register(t3);
+Texture2D<float3> MasksTexture : register(t3);
 
 RWTexture2D<float4> MainRW : register(u0);
 RWTexture2D<float4> NormalTAAMaskSpecularMaskRW : register(u1);
@@ -39,6 +39,17 @@ Texture2D<float4> SsgiYTexture : register(t11);
 Texture2D<float4> SsgiCoCgTexture : register(t12);
 Texture2D<float4> SsgiSpecularTexture : register(t13);
 
+void SampleSSGI(uint2 pixCoord, float3 normalWS, out float ao, out float3 il)
+{
+	ao = 1 - SsgiAoTexture[pixCoord];
+	float4 ssgiIlYSh = SsgiYTexture[pixCoord];
+	// without ZH hallucination
+	// float ssgiIlY = SphericalHarmonics::FuncProductIntegral(ssgiIlYSh, SphericalHarmonics::EvaluateCosineLobe(normalWS));
+	float ssgiIlY = SphericalHarmonics::SHHallucinateZH3Irradiance(ssgiIlYSh, normalWS);
+	float2 ssgiIlCoCg = SsgiCoCgTexture[pixCoord];
+	il = max(0, Color::YCoCgToRGB(float3(ssgiIlY, ssgiIlCoCg)));
+}
+
 void SampleSSGISpecular(uint2 pixCoord, sh2 lobe, out float ao, out float3 il, in float3 normal, in float3 view)
 {
 	// https://www.iryoku.com/stare-into-the-future/
@@ -95,21 +106,73 @@ void SampleSSGISpecular(uint2 pixCoord, sh2 lobe, out float ao, out float3 il, i
 
 	float glossiness = normalGlossiness.z;
 
-	float3 color = Color::GammaToLinear(diffuseColor) + specularColor;
+	float3 linDiffuseColor = Color::GammaToLinear(diffuseColor);
+	float3 normalWS = normalize(mul(FrameBuffer::CameraViewInverse[eyeIndex], float4(normalVS, 0)).xyz);
 
-#if defined(DYNAMIC_CUBEMAPS)
+#if defined(SSGI)
+#	if defined(VR)
+	float3 uvF = float3((dispatchID.xy + 0.5) * SharedData::BufferDim.zw, depth);  // calculate high precision uv of initial eye
+	float3 uv2 = Stereo::ConvertStereoUVToOtherEyeStereoUV(uvF, eyeIndex, false);  // calculate other eye uv
+	float3 uv1Mono = Stereo::ConvertFromStereoUV(uvF, eyeIndex);
+	float3 uv2Mono = Stereo::ConvertFromStereoUV(uv2, (1 - eyeIndex));
+	uint2 pixCoord2 = (uint2)(uv2.xy / SharedData::BufferDim.zw - 0.5);
+#	endif
 
-	float3 reflectance = ReflectanceTexture[dispatchID.xy];
+	float ssgiAo;
+	float3 ssgiIl;
+	SampleSSGI(dispatchID.xy, normalWS, ssgiAo, ssgiIl);
 
-	if (reflectance.x > 0.0 || reflectance.y > 0.0 || reflectance.z > 0.0) {
-		float3 normalWS = normalize(mul(FrameBuffer::CameraViewInverse[eyeIndex], float4(normalVS, 0)).xyz);
+#	if defined(VR)
+	float ssgiAo2;
+	float3 ssgiIl2;
+	SampleSSGI(pixCoord2, normalWS, ssgiAo2, ssgiIl2);
+
+	float4 ssgiMixed = Stereo::BlendEyeColors(uv1Mono, float4(ssgiIl, ssgiAo), uv2Mono, float4(ssgiIl2, ssgiAo2));
+	ssgiAo = ssgiMixed.a;
+	ssgiIl = ssgiMixed.rgb;
+#	endif
+
+	float3 directionalAmbientColor = max(0, mul(SharedData::DirectionalAmbient, float4(normalWS, 1.0)));
+	directionalAmbientColor *= albedo;
+
+	directionalAmbientColor = Color::RGBToYCoCg(directionalAmbientColor);
+	directionalAmbientColor.x = MasksTexture[dispatchID.xy].z;
+	directionalAmbientColor = Color::YCoCgToRGB(directionalAmbientColor);
+	directionalAmbientColor = max(0, directionalAmbientColor);
 
-		float wetnessMask = MasksTexture[dispatchID.xy].z * 2.0 - 1.0;
+	float maxScale = 1.0;
+	if (directionalAmbientColor.x > 0.0)
+		maxScale = min(maxScale, diffuseColor.x / directionalAmbientColor.x);
+	if (directionalAmbientColor.y > 0.0)
+		maxScale = min(maxScale, diffuseColor.y / directionalAmbientColor.y);
+	if (directionalAmbientColor.z > 0.0)
+		maxScale = min(maxScale, diffuseColor.z / directionalAmbientColor.z);
+	directionalAmbientColor *= maxScale;
 
-		normalWS.z = wetnessMask;
-		float xyLength = sqrt(max(0.0, 1.0 - wetnessMask * wetnessMask));
-		normalWS.xy = normalize(normalWS.xy) * xyLength;
+	diffuseColor = max(0.0, diffuseColor - directionalAmbientColor);
 
+	linDiffuseColor = Color::GammaToLinear(diffuseColor);
+#	if defined(INTERIOR)
+	linDiffuseColor *= ssgiAo;
+#	else
+	linDiffuseColor *= sqrt(ssgiAo);
+#	endif
+	diffuseColor = Color::LinearToGamma(linDiffuseColor);
+
+	diffuseColor += Color::LinearToGamma(Color::GammaToLinear(directionalAmbientColor) * ssgiAo);
+
+	linDiffuseColor = Color::GammaToLinear(diffuseColor);
+
+	linDiffuseColor += ssgiIl * Color::GammaToLinear(albedo);
+#endif
+
+	float3 color = linDiffuseColor + specularColor;
+
+#if defined(DYNAMIC_CUBEMAPS)
+
+	float3 reflectance = ReflectanceTexture[dispatchID.xy];
+
+	if (reflectance.x > 0.0 || reflectance.y > 0.0 || reflectance.z > 0.0) {
 		float3 V = normalize(positionWS.xyz);
 		float3 R = reflect(V, normalWS);
 

package/Shaders/DistantTree.hlsl

@@ -235,7 +235,6 @@ PS_OUTPUT main(PS_INPUT input)
 	float3 ddy = ddy_coarse(input.WorldPosition.xyz);
 	float3 normal = -normalize(cross(ddx, ddy));
 
-#			if !defined(SSGI)
 	float3 directionalAmbientColor = max(0, mul(SharedData::DirectionalAmbient, float4(normal, 1.0)));
 #				if defined(IBL)
 	if (SharedData::iblSettings.EnableDiffuseIBL) {
@@ -244,7 +243,6 @@ PS_OUTPUT main(PS_INPUT input)
 	}
 #				endif
 	diffuseColor += directionalAmbientColor;
-#			endif
 
 	psout.Diffuse.xyz = diffuseColor * baseColor.xyz;
 	psout.Diffuse.w = 1;

package/Shaders/Effect.hlsl

@@ -427,9 +427,7 @@ struct PS_OUTPUT
 #	elif defined(NORMALS)
 	float4 NormalGlossiness : SV_Target2;
 #	endif
-#	if defined(MULTBLEND) || defined(MULTBLEND_DECAL)
 	float4 Albedo : SV_Target3;
-#	endif
 	float4 Specular : SV_Target4;
 	float4 Reflectance : SV_Target5;
 	float4 Masks : SV_Target6;
@@ -861,6 +859,7 @@ PS_OUTPUT main(PS_INPUT input)
 	psout.Reflectance = float4(psout.Diffuse.xyz, finalColor.w);
 	psout.Masks = float4(Color::RGBToLuminance(psout.Diffuse.xyz).xxx, finalColor.w);
 #else
+	psout.Albedo = float4(psout.Diffuse.xyz, finalColor.w);
 	psout.Specular = float4(0, 0, 0, finalColor.w);
 	psout.Reflectance = float4(0, 0, 0, finalColor.w);
 	psout.Masks = float4(0, 0, 0, finalColor.w);