feat: add deferred rendering

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "extern/CommonLibSSE-NG"]
 	path = extern/CommonLibSSE-NG
 	url = https://github.com/alandtse/CommonLibVR.git
+[submodule "extern/NVAPI"]
+	path = extern/NVAPI
+	url = https://github.com/NVIDIA/nvapi.git

CMakeLists.txt

@@ -40,11 +40,16 @@ find_package(pystring CONFIG REQUIRED)
 find_package(cppwinrt CONFIG REQUIRED)
 find_package(unordered_dense CONFIG REQUIRED)
 find_package(efsw CONFIG REQUIRED)
+
+set(NVAPI_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/extern/nvapi/" CACHE STRING "Path to NVAPI include headers/shaders" )
+set(NVAPI_LIBRARY "${CMAKE_SOURCE_DIR}/extern/nvapi/amd64/nvapi64.lib" CACHE STRING "Path to NVAPI .lib file")
+
 target_include_directories(
 	${PROJECT_NAME}
 	PRIVATE
 	${BSHOSHANY_THREAD_POOL_INCLUDE_DIRS}
 	${CLIB_UTIL_INCLUDE_DIRS}
+	${NVAPI_INCLUDE_DIR}
 )
 
 target_link_libraries(
@@ -63,6 +68,7 @@ target_link_libraries(
 	pystring::pystring
 	unordered_dense::unordered_dense
 	efsw::efsw
+	 ${NVAPI_LIBRARY} 
 )
 
 # https://gitlab.kitware.com/cmake/cmake/-/issues/24922#note_1371990

features/Cloud Shadows/Shaders/CloudShadows/CloudShadows.hlsli → features/Cloud Shadows/Shaders/CloudShadows/output.cs.hlsl

@@ -1,20 +1,23 @@
+#include "../Common/DeferredShared.hlsli"
+#include "../Common/VR.hlsli"
+
 struct PerPassCloudShadow
 {
 	uint EnableCloudShadows;
-
 	float CloudHeight;
 	float PlanetRadius;
-
 	float EffectMix;
-
 	float TransparencyPower;
-	float AbsorptionAmbient;
-
 	float RcpHPlusR;
 };
 
-StructuredBuffer<PerPassCloudShadow> perPassCloudShadow : register(t23);
-TextureCube<float4> cloudShadows : register(t40);
+StructuredBuffer<PerPassCloudShadow> perPassCloudShadow : register(t0);
+TextureCube<float4> cloudShadows : register(t1);
+Texture2D<unorm half> TexDepth : register(t2);
+
+RWTexture2D<unorm float> RWTexShadowMask : register(u0);
+
+SamplerState defaultSampler;
 
 float3 getCloudShadowSampleDir(float3 rel_pos, float3 eye_to_sun)
 {
@@ -38,13 +41,40 @@ float3 getCloudShadowSampleDirFlatEarth(float3 rel_pos, float3 eye_to_sun)
 	return v;
 }
 
-float3 getCloudShadowMult(float3 rel_pos, float3 eye_to_sun, SamplerState samp)
+float3 getCloudShadowMult(float3 rel_pos, float3 eye_to_sun)
 {
 	// float3 cloudSampleDir = getCloudShadowSampleDirFlatEarth(rel_pos, eye_to_sun).xyz;
 	float3 cloudSampleDir = getCloudShadowSampleDir(rel_pos, eye_to_sun).xyz;
 
-	float4 cloudCubeSample = cloudShadows.Sample(samp, cloudSampleDir);
+	float4 cloudCubeSample = cloudShadows.SampleLevel(defaultSampler, cloudSampleDir, 0);  // TODO Sample in pixel shader
 	float alpha = pow(saturate(cloudCubeSample.w), perPassCloudShadow[0].TransparencyPower);
 
 	return lerp(1.0, 1.0 - alpha, perPassCloudShadow[0].EffectMix);
+}
+
+[numthreads(32, 32, 1)] void main(uint2 dtid
+								  : SV_DispatchThreadID) {
+	float2 uv = (dtid + .5) * RcpBufferDim;
+#ifdef VR
+	const uint eyeIndex = uv > .5;
+#else
+	const uint eyeIndex = 0;
+#endif
+
+	float3 ndc = float3(ConvertToStereoUV(uv, eyeIndex), 1);
+	ndc = ndc * 2 - 1;
+	ndc.y = -ndc.y;
+	ndc.z = TexDepth[dtid];
+
+	if (ndc.z > 0.9999)
+		return;
+
+	float4 worldPos = mul(InvViewMatrix[eyeIndex], mul(InvProjMatrix[eyeIndex], float4(ndc, 1)));
+	worldPos.xyz /= worldPos.w;
+
+	float3 dirLightDirWS = mul((float3x3)InvViewMatrix[eyeIndex], DirLightDirectionVS[eyeIndex].xyz);
+	float cloudShadow = getCloudShadowMult(worldPos.xyz, dirLightDirWS);
+
+	half shadow = RWTexShadowMask[dtid];
+	RWTexShadowMask[dtid] = shadow * cloudShadow;
 }

features/Grass Lighting/Shaders/RunGrass.hlsl

@@ -313,10 +313,6 @@ float3x3 CalculateTBN(float3 N, float3 p, float2 uv)
 #		include "DynamicCubemaps/DynamicCubemaps.hlsli"
 #	endif
 
-#	if defined(CLOUD_SHADOWS)
-#		include "CloudShadows/CloudShadows.hlsli"
-#	endif
-
 PS_OUTPUT main(PS_INPUT input, bool frontFace
 			   : SV_IsFrontFace)
 {
@@ -389,14 +385,6 @@ PS_OUTPUT main(PS_INPUT input, bool frontFace
 		dirLightColor *= SunlightScale;
 	}
 
-#		if defined(CLOUD_SHADOWS)
-	float3 cloudShadowMult = 1.0;
-	if (perPassCloudShadow[0].EnableCloudShadows && !lightingData[0].Reflections) {
-		cloudShadowMult = getCloudShadowMult(input.WorldPosition.xyz, DirLightDirection.xyz, SampColorSampler);
-		dirLightColor *= cloudShadowMult;
-	}
-#		endif
-
 	dirLightColor *= shadowColor.x;
 
 #		if defined(SCREEN_SPACE_SHADOWS)
@@ -480,10 +468,6 @@ PS_OUTPUT main(PS_INPUT input, bool frontFace
 #		endif
 
 	float3 directionalAmbientColor = mul(DirectionalAmbient, float4(worldNormal.xyz, 1));
-#		if defined(CLOUD_SHADOWS)
-	if (perPassCloudShadow[0].EnableCloudShadows && !lightingData[0].Reflections)
-		directionalAmbientColor *= lerp(1.0, cloudShadowMult, perPassCloudShadow[0].AbsorptionAmbient);
-#		endif
 	lightsDiffuseColor += directionalAmbientColor;
 
 	diffuseColor += lightsDiffuseColor;

features/Screen Space GI/Shaders/Features/ScreenSpaceGI.ini

@@ -0,0 +1,2 @@
+[Info]
+Version = 2-9-0

features/Screen Space GI/Shaders/ScreenSpaceGI/common.hlsli

@@ -0,0 +1,198 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016-2021, Intel Corporation
+//
+// SPDX-License-Identifier: MIT
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// XeGTAO is based on GTAO/GTSO "Jimenez et al. / Practical Real-Time Strategies for Accurate Indirect Occlusion",
+// https://www.activision.com/cdn/research/Practical_Real_Time_Strategies_for_Accurate_Indirect_Occlusion_NEW%20VERSION_COLOR.pdf
+//
+// Implementation:  Filip Strugar (filip.strugar@intel.com), Steve Mccalla <stephen.mccalla@intel.com>         (\_/)
+// Version:         (see XeGTAO.h)                                                                            (='.'=)
+// Details:         https://github.com/GameTechDev/XeGTAO                                                     (")_(")
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// with additional edits by FiveLimbedCat/ProfJack
+
+#ifndef SSGI_COMMON
+#define SSGI_COMMON
+
+#ifndef USE_HALF_FLOAT_PRECISION
+#	define USE_HALF_FLOAT_PRECISION 1
+#endif
+
+#if (USE_HALF_FLOAT_PRECISION != 0)
+#	if 1  // old fp16 approach (<SM6.2)
+typedef min16float lpfloat;
+typedef min16float2 lpfloat2;
+typedef min16float3 lpfloat3;
+typedef min16float4 lpfloat4;
+typedef min16float3x3 lpfloat3x3;
+#	else  // new fp16 approach (requires SM6.2 and -enable-16bit-types) - WARNING: perf degradation noticed on some HW, while the old (min16float) path is mostly at least a minor perf gain so this is more useful for quality testing
+typedef float16_t lpfloat;
+typedef float16_t2 lpfloat2;
+typedef float16_t3 lpfloat3;
+typedef float16_t4 lpfloat4;
+typedef float16_t3x3 lpfloat3x3;
+#	endif
+#else
+typedef float lpfloat;
+typedef float2 lpfloat2;
+typedef float3 lpfloat3;
+typedef float4 lpfloat4;
+typedef float3x3 lpfloat3x3;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../Common/DeferredShared.hlsli"
+
+cbuffer SSGICB : register(b1)
+{
+	float4x4 PrevInvViewMat[2];
+	float4 NDCToViewMul;
+	float4 NDCToViewAdd;
+	float4 NDCToViewMul_x_PixelSize;
+
+	float2 FrameDim;
+	float2 RcpFrameDim;
+	uint FrameIndex;
+
+	uint NumSlices;
+	uint NumSteps;
+	float DepthMIPSamplingOffset;
+
+	float EffectRadius;
+	float EffectFalloffRange;
+	float ThinOccluderCompensation;
+	float Thickness;
+	float2 DepthFadeRange;
+	float DepthFadeScaleConst;
+
+	float BackfaceStrength;
+	float GIBounceFade;
+	float GIDistanceCompensation;
+	float GICompensationMaxDist;
+
+	float AOPower;
+	float GIStrength;
+
+	float DepthDisocclusion;
+	uint MaxAccumFrames;
+
+	float pad;
+};
+
+SamplerState samplerPointClamp : register(s0);
+SamplerState samplerLinearClamp : register(s1);
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef HALF_RES
+const static float res_scale = .5;
+#	define READ_DEPTH(tex, px) tex.Load(int3(px, 1))
+#	define FULLRES_LOAD(tex, px, uv, samp) tex.SampleLevel(samp, uv, 0)
+#else
+const static float res_scale = 1.;
+#	define READ_DEPTH(tex, px) tex[px]
+#	define FULLRES_LOAD(tex, px, uv, samp) tex[px]
+#endif
+
+#ifdef VR
+#	define GET_EYE_IDX(uv) (uv.x > 0.5)
+#else
+#	define GET_EYE_IDX(uv) (0)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define ISNAN(x) (!(x < 0.f || x > 0.f || x == 0.f))
+
+// http://h14s.p5r.org/2012/09/0x5f3759df.html, [Drobot2014a] Low Level Optimizations for GCN, https://blog.selfshadow.com/publications/s2016-shading-course/activision/s2016_pbs_activision_occlusion.pdf slide 63
+lpfloat FastSqrt(float x)
+{
+	return (lpfloat)(asfloat(0x1fbd1df5 + (asint(x) >> 1)));
+}
+
+// input [-1, 1] and output [0, PI], from https://seblagarde.wordpress.com/2014/12/01/inverse-trigonometric-functions-gpu-optimization-for-amd-gcn-architecture/
+lpfloat FastACos(lpfloat inX)
+{
+	const lpfloat PI = 3.141593;
+	const lpfloat HALF_PI = 1.570796;
+	lpfloat x = abs(inX);
+	lpfloat res = -0.156583 * x + HALF_PI;
+	res *= FastSqrt(1.0 - x);
+	return (inX >= 0) ? res : PI - res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// Inputs are screen XY and viewspace depth, output is viewspace position
+float3 ScreenToViewPosition(const float2 screenPos, const float viewspaceDepth, const uint eyeIndex)
+{
+	const float2 _mul = eyeIndex == 0 ? NDCToViewMul.xy : NDCToViewMul.zw;
+	const float2 _add = eyeIndex == 0 ? NDCToViewAdd.xy : NDCToViewAdd.zw;
+
+	float3 ret;
+	ret.xy = (_mul * screenPos.xy + _add) * viewspaceDepth;
+	ret.z = viewspaceDepth;
+	return ret;
+}
+
+float ScreenToViewDepth(const float screenDepth)
+{
+	return (CameraData.w / (-screenDepth * CameraData.z + CameraData.x));
+}
+
+float3 ViewToWorldPosition(const float3 pos, const float4x4 invView)
+{
+	float4 worldpos = mul(invView, float4(pos, 1));
+	return worldpos.xyz / worldpos.w;
+}
+
+float3 ViewToWorldVector(const float3 vec, const float4x4 invView)
+{
+	return mul((float3x3)invView, vec);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// "Efficiently building a matrix to rotate one vector to another"
+// http://cs.brown.edu/research/pubs/pdfs/1999/Moller-1999-EBA.pdf / https://dl.acm.org/doi/10.1080/10867651.1999.10487509
+// (using https://github.com/assimp/assimp/blob/master/include/assimp/matrix3x3.inl#L275 as a code reference as it seems to be best)
+lpfloat3x3 RotFromToMatrix(lpfloat3 from, lpfloat3 to)
+{
+	const lpfloat e = dot(from, to);
+	const lpfloat f = abs(e);  //(e < 0)? -e:e;
+
+	// WARNING: This has not been tested/worked through, especially not for 16bit floats; seems to work in our special use case (from is always {0, 0, -1}) but wouldn't use it in general
+	if (f > lpfloat(1.0 - 0.0003))
+		return lpfloat3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);
+
+	const lpfloat3 v = cross(from, to);
+	/* ... use this hand optimized version (9 mults less) */
+	const lpfloat h = (1.0) / (1.0 + e); /* optimization by Gottfried Chen */
+	const lpfloat hvx = h * v.x;
+	const lpfloat hvz = h * v.z;
+	const lpfloat hvxy = hvx * v.y;
+	const lpfloat hvxz = hvx * v.z;
+	const lpfloat hvyz = hvz * v.y;
+
+	lpfloat3x3 mtx;
+	mtx[0][0] = e + hvx * v.x;
+	mtx[0][1] = hvxy - v.z;
+	mtx[0][2] = hvxz + v.y;
+
+	mtx[1][0] = hvxy + v.z;
+	mtx[1][1] = e + h * v.y * v.y;
+	mtx[1][2] = hvyz - v.x;
+
+	mtx[2][0] = hvxz - v.y;
+	mtx[2][1] = hvyz + v.x;
+	mtx[2][2] = e + hvz * v.z;
+
+	return mtx;
+}
+
+#endif