Workaround a DX12 validation issue

AnKi/Renderer/ClusterBinning.cpp

@@ -179,7 +179,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 				} consts;
 
 				consts.m_cameraOrigin = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
-				consts.m_zSplitCountOverFrustumLength = F32(getRenderer().getZSplitCount()) / (ctx.m_cameraFar - ctx.m_cameraNear);
+				consts.m_zSplitCountOverFrustumLength = F32(getRenderer().getZSplitCount()) / (ctx.m_matrices.m_far - ctx.m_matrices.m_near);
 				consts.m_renderingSize = Vec2(getRenderer().getInternalResolution());
 				consts.m_tileCountX = getRenderer().getTileCounts().x();
 				consts.m_tileCount = getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y();

AnKi/Renderer/Common.h

@@ -79,9 +79,6 @@ public:
 	CommonMatrices m_matrices;
 	CommonMatrices m_prevMatrices;
 
-	F32 m_cameraNear = 0.0f;
-	F32 m_cameraFar = 0.0f;
-
 	/// The render target that the Renderer will populate.
 	RenderTargetHandle m_swapchainRenderTarget;
 

AnKi/Renderer/LightShading.cpp

@@ -195,8 +195,8 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		} consts;
 		consts.m_zSplitCount = F32(getRenderer().getZSplitCount());
 		consts.m_finalZSplit = F32(getRenderer().getVolumetricFog().getFinalClusterInZ());
-		consts.m_near = ctx.m_cameraNear;
-		consts.m_far = ctx.m_cameraFar;
+		consts.m_near = ctx.m_matrices.m_near;
+		consts.m_far = ctx.m_matrices.m_far;
 
 		cmdb.setFastConstants(&consts, sizeof(consts));
 

AnKi/Renderer/MotionBlur.cpp

@@ -149,10 +149,10 @@ void MotionBlur::populateRenderGraph(RenderingContext& ctx)
 				U32 m_frame;
 				F32 m_far;
 			} consts;
-			consts.m_depthLinearizationParams.x() = (ctx.m_cameraNear - ctx.m_cameraFar) / ctx.m_cameraNear;
-			consts.m_depthLinearizationParams.y() = ctx.m_cameraFar / ctx.m_cameraNear;
+			consts.m_depthLinearizationParams.x() = (ctx.m_matrices.m_near - ctx.m_matrices.m_far) / ctx.m_matrices.m_near;
+			consts.m_depthLinearizationParams.y() = ctx.m_matrices.m_far / ctx.m_matrices.m_near;
 			consts.m_frame = getRenderer().getFrameCount() % 32;
-			consts.m_far = ctx.m_cameraFar;
+			consts.m_far = ctx.m_matrices.m_far;
 			cmdb.setFastConstants(&consts, sizeof(consts));
 
 			if(g_preferComputeCVar)

AnKi/Renderer/Renderer.cpp

@@ -368,15 +368,13 @@ void Renderer::writeGlobalRendererConstants(RenderingContext& ctx, GlobalRendere
 	Plane nearPlane;
 	extractClipPlane(ctx.m_matrices.m_viewProjection, FrustumPlaneType::kNear, nearPlane);
 	consts.m_nearPlaneWSpace = Vec4(nearPlane.getNormal().xyz(), nearPlane.getOffset());
-	consts.m_near = ctx.m_cameraNear;
-	consts.m_far = ctx.m_cameraFar;
 	consts.m_cameraPosition = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
 
 	consts.m_tileCounts = m_tileCounts;
 	consts.m_zSplitCount = m_zSplitCount;
-	consts.m_zSplitCountOverFrustumLength = F32(m_zSplitCount) / (ctx.m_cameraFar - ctx.m_cameraNear);
-	consts.m_zSplitMagic.x() = (ctx.m_cameraNear - ctx.m_cameraFar) / (ctx.m_cameraNear * F32(m_zSplitCount));
-	consts.m_zSplitMagic.y() = ctx.m_cameraFar / (ctx.m_cameraNear * F32(m_zSplitCount));
+	consts.m_zSplitCountOverFrustumLength = F32(m_zSplitCount) / (ctx.m_matrices.m_far - ctx.m_matrices.m_near);
+	consts.m_zSplitMagic.x() = (ctx.m_matrices.m_near - ctx.m_matrices.m_far) / (ctx.m_matrices.m_near * F32(m_zSplitCount));
+	consts.m_zSplitMagic.y() = ctx.m_matrices.m_far / (ctx.m_matrices.m_near * F32(m_zSplitCount));
 	consts.m_lightVolumeLastZSplit = min(g_volumetricLightingAccumulationFinalZSplitCVar - 1, m_zSplitCount);
 
 	consts.m_reflectionProbesMipCount = F32(m_probeReflections->getReflectionTextureMipmapCount());
@@ -801,8 +799,8 @@ Error Renderer::render(Texture* presentTex)
 	ctx.m_matrices.m_projMat00_11_22_23 = Vec4(ctx.m_matrices.m_projection(0, 0), ctx.m_matrices.m_projection(1, 1),
 											   ctx.m_matrices.m_projection(2, 2), ctx.m_matrices.m_projection(2, 3));
 
-	ctx.m_cameraNear = cam.getNear();
-	ctx.m_cameraFar = cam.getFar();
+	ctx.m_matrices.m_near = cam.getNear();
+	ctx.m_matrices.m_far = cam.getFar();
 
 	// Allocate global constants
 	GlobalRendererConstants* globalConsts;

AnKi/Renderer/Sky.cpp

@@ -201,6 +201,9 @@ void GeneratedSky::populateRenderGraph(RenderingContext& ctx)
 			rgraphCtx.bindSrv(0, 0, transmittanceLutRt);
 			cmdb.bindUav(0, 0, ctx.m_globalRenderingConstantsBuffer);
 
+			const UVec4 consts(offsetof(GlobalRendererConstants, m_directionalLight));
+			cmdb.setFastConstants(&consts, sizeof(consts));
+
 			cmdb.dispatchCompute(1, 1, 1);
 		});
 	}

AnKi/Renderer/Ssao.cpp

@@ -182,7 +182,8 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 			const UVec2 rez = (g_ssaoQuarterRezCVar) ? getRenderer().getInternalResolution() / 2u : getRenderer().getInternalResolution();
 
 			SsaoSpatialDenoiseConstants consts;
-			computeLinearizeDepthOptimal(ctx.m_cameraNear, ctx.m_cameraFar, consts.m_linearizeDepthParams.x(), consts.m_linearizeDepthParams.y());
+			computeLinearizeDepthOptimal(ctx.m_matrices.m_near, ctx.m_matrices.m_far, consts.m_linearizeDepthParams.x(),
+										 consts.m_linearizeDepthParams.y());
 			consts.m_viewToWorldMat = ctx.m_matrices.m_cameraTransform;
 			cmdb.setFastConstants(&consts, sizeof(consts));
 

AnKi/Renderer/VolumetricFog.cpp

@@ -67,8 +67,8 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 		consts.m_fogDiffuse = (sky) ? sky->getFogDiffuseColor() : Vec3(0.0f);
 		consts.m_fogScatteringCoeff = (sky) ? sky->getFogScatteringCoefficient() : 0.0f;
 		consts.m_fogAbsorptionCoeff = (sky) ? sky->getFogAbsorptionCoefficient() : 0.0f;
-		consts.m_near = ctx.m_cameraNear;
-		consts.m_far = ctx.m_cameraFar;
+		consts.m_near = ctx.m_matrices.m_near;
+		consts.m_far = ctx.m_matrices.m_far;
 		consts.m_zSplitCountf = F32(getRenderer().getZSplitCount());
 		consts.m_volumeSize = UVec3(m_volumeSize);
 		consts.m_maxZSplitsToProcessf = F32(m_finalZSplit + 1);

AnKi/Shaders/ForwardShadingCommon.hlsl

@@ -99,7 +99,7 @@ Vec3 computeLightColorLow(Vec3 diffCol, Vec3 worldPos, Vec4 svPosition)
 	ANKI_MAYBE_UNUSED(worldPos);
 
 	const Vec2 uv = svPosition.xy / g_globalRendererConstants.m_renderingSize;
-	const F32 linearDepth = linearizeDepth(svPosition.z, g_globalRendererConstants.m_near, g_globalRendererConstants.m_far);
+	const F32 linearDepth = linearizeDepth(svPosition.z, g_globalRendererConstants.m_matrices.m_near, g_globalRendererConstants.m_matrices.m_far);
 	const F32 w = linearDepth * (F32(g_globalRendererConstants.m_zSplitCount) / F32(g_globalRendererConstants.m_lightVolumeLastZSplit + 1u));
 	const Vec3 uvw = Vec3(uv, w);
 

AnKi/Shaders/Include/MiscRendererTypes.h

@@ -61,7 +61,8 @@ struct CommonMatrices
 	Vec4 m_projMat00_11_22_23;
 
 	Vec2 m_jitterOffsetNdc;
-	Vec2 m_padding;
+	F32 m_near;
+	F32 m_far;
 };
 
 struct Sky
@@ -105,10 +106,6 @@ struct GlobalRendererConstants
 	U32 m_lightVolumeLastZSplit;
 	U32 m_padding1;
 
-	UVec2 m_padding0;
-	F32 m_near;
-	F32 m_far;
-
 	DirectionalLight m_directionalLight;
 
 	CommonMatrices m_matrices;

AnKi/Shaders/ShadowmapsResolve.ankiprog

@@ -120,8 +120,8 @@ RVec4 main(VertOut input) : SV_TARGET0
 	{
 		const U32 shadowCascadeCount = dirLight.m_shadowCascadeCount_31bit_active_1bit >> 1u;
 
-		const RF32 positiveZViewSpace =
-			testPlanePoint(g_globalConstants.m_nearPlaneWSpace.xyz, g_globalConstants.m_nearPlaneWSpace.w, worldPos) + g_globalConstants.m_near;
+		const RF32 positiveZViewSpace = testPlanePoint(g_globalConstants.m_nearPlaneWSpace.xyz, g_globalConstants.m_nearPlaneWSpace.w, worldPos)
+										+ g_globalConstants.m_matrices.m_near;
 
 		const F32 lastCascadeDistance = dirLight.m_shadowCascadeDistances[shadowCascadeCount - 1u];
 		RF32 shadowFactor;

AnKi/Shaders/Sky.ankiprog

@@ -431,14 +431,28 @@ Vec3 raymarchScattering(Vec3 pos, Vec3 rayDir, Vec3 dirToSun, F32 tMax, F32 numS
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
 
 Texture2D<Vec4> g_tLutTex : register(t0);
-globallycoherent RWStructuredBuffer<GlobalRendererConstants> g_globalConstants : register(u0);
+
+// Make it a BAB and not a RWStructuredBuffer because the underlying struct is too big and DXC validation complains
+RWByteAddressBuffer g_globalConstants : register(u0);
+
+struct Consts
+{
+	U32 m_offsetofDirectionalLight;
+	U32 m_padding1;
+	U32 m_padding2;
+	U32 m_padding3;
+};
+ANKI_FAST_CONSTANTS(Consts, g_consts);
 
 [numthreads(1, 1, 1)] void main(UVec2 svDispatchThreadId : SV_DISPATCHTHREADID)
 {
-	const Vec3 sunTransmittance = getValFromTLut(g_tLutTex, kViewPos, -g_globalConstants[0].m_directionalLight.m_direction);
-	const F32 sunPower = g_globalConstants[0].m_directionalLight.m_power;
+	DirectionalLight dirl = g_globalConstants.Load<DirectionalLight>(g_consts.m_offsetofDirectionalLight);
+
+	const Vec3 sunTransmittance = getValFromTLut(g_tLutTex, kViewPos, -dirl.m_direction);
+	const F32 sunPower = dirl.m_power;
 
-	g_globalConstants[0].m_directionalLight.m_diffuseColor = Vec4(sunPower * sunTransmittance, 0.0f);
+	dirl.m_diffuseColor = Vec4(sunPower * sunTransmittance, 0.0f);
+	g_globalConstants.Store<DirectionalLight>(g_consts.m_offsetofDirectionalLight, dirl);
 }
 #endif // ANKI_TECHNIQUE_ComputeSunColor
 

AnKi/Shaders/VolumetricLightingAccumulation.ankiprog

@@ -53,7 +53,8 @@ Vec3 worldPosInsideClusterAndZViewSpace(Vec3 relativePos, out F32 negativeZViewS
 	uvw.z = linearDepth;
 
 	// Z view space
-	negativeZViewSpace = linearDepth * (g_globalConstants.m_far - g_globalConstants.m_near) + g_globalConstants.m_near;
+	negativeZViewSpace =
+		linearDepth * (g_globalConstants.m_matrices.m_far - g_globalConstants.m_matrices.m_near) + g_globalConstants.m_matrices.m_near;
 	const F32 zViewSpace = -negativeZViewSpace;
 
 	// Get the position in view space
@@ -279,7 +280,7 @@ Vec4 accumulateLightsAndFog(Cluster cluster, Vec3 worldPos, F32 negativeZViewSpa
 		// Read prev
 		if(all(prevClipPos.xy > -1.0) && all(prevClipPos.xy < 1.0))
 		{
-			const F32 linearDepth = linearizeDepth(prevClipPos.z, g_globalConstants.m_near, g_globalConstants.m_far);
+			const F32 linearDepth = linearizeDepth(prevClipPos.z, g_globalConstants.m_matrices.m_near, g_globalConstants.m_matrices.m_far);
 			const Vec3 uvw = Vec3(ndcToUv(prevClipPos.xy), linearDepth * (F32(g_globalConstants.m_zSplitCount) / g_fogUnis.m_maxZSplitsToProcessf));
 			const Vec4 history = g_prevVolume.SampleLevel(g_linearAnyClampSampler, uvw, 0.0);
 			lightAndFog = lerp(history, lightAndFog, 1.0 / 16.0);