Moving Bloom shader to HLSL

AnKi/Renderer/Bloom.cpp

@@ -154,8 +154,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			{
 				rgraphCtx.bindImage(0, 3, m_runCtx.m_exposureRt, TextureSubresourceInfo());
 
-				dispatchPPCompute(cmdb, m_workgroupSize[0], m_workgroupSize[1], m_exposure.m_width,
-								  m_exposure.m_height);
+				dispatchPPCompute(cmdb, 8, 8, m_exposure.m_width, m_exposure.m_height);
 			}
 			else
 			{

AnKi/Shaders/Blit.hlsl

@@ -0,0 +1,71 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#include <AnKi/Shaders/Functions.hlsl>
+
+[[vk::binding(0)]] SamplerState g_linearAnyClampSampler;
+[[vk::binding(1)]] Texture2D<RVec4> g_inputTex;
+
+#if defined(ANKI_COMPUTE_SHADER)
+#	define USE_COMPUTE 1
+#else
+#	define USE_COMPUTE 0
+#endif
+
+#if USE_COMPUTE
+[[vk::binding(2)]] RWTexture2D<RVec4> g_outUav;
+
+struct Uniforms
+{
+	Vec2 m_viewportSize;
+	UVec2 m_viewportSizeU;
+};
+
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_pc;
+
+struct CompIn
+{
+	UVec3 m_svDispatchThreadId : SV_DISPATCHTHREADID;
+};
+#else
+struct VertOut
+{
+	[[vk::location(0)]] Vec2 m_uv : TEXCOORD;
+	Vec4 m_svPosition : SV_POSITION;
+};
+
+struct FragOut
+{
+	RVec3 m_svTarget : SV_TARGET0;
+};
+#endif
+
+#if USE_COMPUTE
+ANKI_NUMTHREADS(8, 8, 1) void main(CompIn input)
+#else
+FragOut main(VertOut input)
+#endif
+{
+#if USE_COMPUTE
+	if(skipOutOfBoundsInvocations(UVec2(8, 8), g_pc.m_viewportSizeU, input.m_svDispatchThreadId.xy))
+	{
+		return;
+	}
+
+	const Vec2 uv = (Vec2(input.m_svDispatchThreadId.xy) + 0.5) / g_pc.m_viewportSize;
+#else
+	const Vec2 uv = input.m_uv;
+#endif
+
+	const RVec3 color = g_inputTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0).rgb;
+
+#if USE_COMPUTE
+	g_outUav[input.m_svDispatchThreadId.xy] = RVec4(color, 0.0);
+#else
+	FragOut output;
+	output.m_svTarget = color;
+	return output;
+#endif
+}

AnKi/Shaders/Bloom.glsl

@@ -1,59 +0,0 @@
-// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#include <AnKi/Shaders/TonemappingFunctions.glsl>
-#include <AnKi/Shaders/Functions.glsl>
-
-ANKI_SPECIALIZATION_CONSTANT_UVEC2(kViewport, 0u);
-
-layout(set = 0, binding = 0) uniform sampler u_linearAnyClampSampler;
-layout(set = 0, binding = 1) uniform ANKI_RP texture2D u_tex; ///< Its the IS RT
-
-layout(push_constant) uniform b_pc
-{
-	Vec4 u_thresholdScalePad2;
-};
-
-const U32 kTonemappingBinding = 2u;
-#include <AnKi/Shaders/TonemappingResources.glsl>
-
-#if defined(ANKI_COMPUTE_SHADER)
-const UVec2 kWorkgroupSize = UVec2(16, 16);
-layout(local_size_x = kWorkgroupSize.x, local_size_y = kWorkgroupSize.y, local_size_z = 1) in;
-
-layout(set = 0, binding = 3) writeonly uniform image2D u_outImg;
-#else
-layout(location = 0) in Vec2 in_uv;
-layout(location = 0) out ANKI_RP Vec3 out_color;
-#endif
-
-void main()
-{
-#if defined(ANKI_COMPUTE_SHADER)
-	if(skipOutOfBoundsInvocations(kWorkgroupSize, kViewport))
-	{
-		return;
-	}
-
-	const Vec2 uv = (Vec2(gl_GlobalInvocationID.xy) + 0.5) / Vec2(kViewport);
-#else
-	const Vec2 uv = in_uv;
-#endif
-
-	ANKI_RP F32 weight = 1.0 / 5.0;
-	ANKI_RP Vec3 color = textureLod(u_tex, u_linearAnyClampSampler, uv, 0.0).rgb * weight;
-	color += textureLodOffset(sampler2D(u_tex, u_linearAnyClampSampler), uv, 0.0, IVec2(+1, +1)).rgb * weight;
-	color += textureLodOffset(sampler2D(u_tex, u_linearAnyClampSampler), uv, 0.0, IVec2(-1, -1)).rgb * weight;
-	color += textureLodOffset(sampler2D(u_tex, u_linearAnyClampSampler), uv, 0.0, IVec2(-1, +1)).rgb * weight;
-	color += textureLodOffset(sampler2D(u_tex, u_linearAnyClampSampler), uv, 0.0, IVec2(+1, -1)).rgb * weight;
-
-	color = tonemap(color, readExposureAndAverageLuminance().y, u_thresholdScalePad2.x) * u_thresholdScalePad2.y;
-
-#if defined(ANKI_COMPUTE_SHADER)
-	imageStore(u_outImg, IVec2(gl_GlobalInvocationID.xy), Vec4(color, 0.0));
-#else
-	out_color = color;
-#endif
-}

AnKi/Shaders/Bloom.hlsl

@@ -0,0 +1,79 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#include <AnKi/Shaders/TonemappingFunctions.hlsl>
+#include <AnKi/Shaders/Functions.hlsl>
+constexpr U32 kTonemappingBinding = 2u;
+#include <AnKi/Shaders/TonemappingResources.hlsl>
+
+ANKI_SPECIALIZATION_CONSTANT_UVEC2(kViewport, 0u);
+
+[[vk::binding(0)]] SamplerState g_linearAnyClampSampler;
+[[vk::binding(1)]] Texture2D g_inTex; ///< Its the IS RT
+
+struct Uniforms
+{
+	Vec4 m_thresholdScalePad2;
+};
+
+[[vk::push_constant]] ConstantBuffer<Uniforms> g_pc;
+
+struct CompIn
+{
+	UVec3 m_svDispatchThreadId : SV_DISPATCHTHREADID;
+};
+
+struct VertOut
+{
+	Vec4 m_position : SV_POSITION;
+	[[vk::location(0)]] Vec2 m_uv : TEXCOORD;
+};
+
+struct FragOut
+{
+	RVec3 m_svTarget : SV_TARGET0;
+};
+
+#if defined(ANKI_COMPUTE_SHADER)
+#	define THREADGROUP_SIZE_X 8
+#	define THREADGROUP_SIZE_Y 8
+[[vk::binding(3)]] RWTexture2D<RVec4> g_outUav;
+#endif
+
+#if defined(ANKI_COMPUTE_SHADER)
+ANKI_NUMTHREADS(THREADGROUP_SIZE_X, THREADGROUP_SIZE_Y, 1) void main(CompIn input)
+#else
+FragOut main(VertOut input)
+#endif
+{
+#if defined(ANKI_COMPUTE_SHADER)
+	if(skipOutOfBoundsInvocations(UVec2(THREADGROUP_SIZE_X, THREADGROUP_SIZE_Y), kViewport, input.m_svDispatchThreadId))
+	{
+		return;
+	}
+
+	const Vec2 uv = (Vec2(input.m_svDispatchThreadId.xy) + 0.5) / Vec2(kViewport);
+#else
+	const Vec2 uv = input.m_uv;
+#endif
+
+	RF32 weight = 1.0 / 5.0;
+	RVec3 color = g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0).rgb * weight;
+	color += g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(+1, +1)).rgb * weight;
+	color += g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(-1, -1)).rgb * weight;
+	color += g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(-1, +1)).rgb * weight;
+	color += g_inTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(+1, -1)).rgb * weight;
+
+	color =
+		tonemap(color, readExposureAndAverageLuminance().y, g_pc.m_thresholdScalePad2.x) * g_pc.m_thresholdScalePad2.y;
+
+#if defined(ANKI_COMPUTE_SHADER)
+	g_outUav[input.m_svDispatchThreadId.xy] = RVec4(color, 0.0);
+#else
+	FragOut output;
+	output.m_svTarget = color;
+	return output;
+#endif
+}

AnKi/Shaders/BloomCompute.ankiprog

@@ -3,6 +3,8 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
+#pragma anki hlsl
+
 #pragma anki start comp
-#include <AnKi/Shaders/Bloom.glsl>
+#include <AnKi/Shaders/Bloom.hlsl>
 #pragma anki end

AnKi/Shaders/BloomRaster.ankiprog

@@ -3,10 +3,12 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
+#pragma anki hlsl
+
 #pragma anki start vert
-#include <AnKi/Shaders/QuadVert.glsl>
+#include <AnKi/Shaders/QuadVert.hlsl>
 #pragma anki end
 
 #pragma anki start frag
-#include <AnKi/Shaders/Bloom.glsl>
+#include <AnKi/Shaders/Bloom.hlsl>
 #pragma anki end

AnKi/Shaders/ClusteredShadingCommon.hlsl

@@ -12,7 +12,7 @@
 //
 #if defined(CLUSTERED_SHADING_UNIFORMS_BINDING)
 [[vk::binding(CLUSTERED_SHADING_UNIFORMS_BINDING, CLUSTERED_SHADING_SET)]] ConstantBuffer<ClusteredShadingUniforms>
-	u_clusteredShading;
+	g_clusteredShading;
 #endif
 
 //
@@ -21,15 +21,15 @@
 #if defined(CLUSTERED_SHADING_LIGHTS_BINDING)
 [[vk::binding(CLUSTERED_SHADING_LIGHTS_BINDING, CLUSTERED_SHADING_SET)]] cbuffer b_pointLights
 {
-	PointLight u_pointLights2[kMaxVisiblePointLights];
+	PointLight g_pointLights[kMaxVisiblePointLights];
 };
 
 [[vk::binding(CLUSTERED_SHADING_LIGHTS_BINDING + 1u, CLUSTERED_SHADING_SET)]] cbuffer b_spotLights
 {
-	SpotLight u_spotLights[kMaxVisibleSpotLights];
+	SpotLight g_spotLights[kMaxVisibleSpotLights];
 };
 
-[[vk::binding(CLUSTERED_SHADING_LIGHTS_BINDING + 2u, CLUSTERED_SHADING_SET)]] Texture2D u_shadowAtlasTex;
+[[vk::binding(CLUSTERED_SHADING_LIGHTS_BINDING + 2u, CLUSTERED_SHADING_SET)]] Texture2D g_shadowAtlasTex;
 #endif
 
 //
@@ -38,11 +38,11 @@
 #if defined(CLUSTERED_SHADING_REFLECTIONS_BINDING)
 [[vk::binding(CLUSTERED_SHADING_REFLECTIONS_BINDING, CLUSTERED_SHADING_SET)]] cbuffer b_reflectionProbes
 {
-	ReflectionProbe u_reflectionProbes[kMaxVisibleReflectionProbes];
+	ReflectionProbe g_reflectionProbes[kMaxVisibleReflectionProbes];
 };
 
 [[vk::binding(CLUSTERED_SHADING_REFLECTIONS_BINDING + 1u, CLUSTERED_SHADING_SET)]] TextureCubeArray<RVec4>
-	u_reflectionsTex;
+	g_reflectionsTex;
 #endif
 
 //
@@ -51,12 +51,12 @@
 #if defined(CLUSTERED_SHADING_DECALS_BINDING)
 [[vk::binding(CLUSTERED_SHADING_DECALS_BINDING, CLUSTERED_SHADING_SET)]] cbuffer b_decals
 {
-	Decal u_decals2[kMaxVisibleDecals];
+	Decal g_decals[kMaxVisibleDecals];
 };
 
-[[vk::binding(CLUSTERED_SHADING_DECALS_BINDING + 1u, CLUSTERED_SHADING_SET)]] Texture2D<RVec4> u_diffuseDecalTex;
+[[vk::binding(CLUSTERED_SHADING_DECALS_BINDING + 1u, CLUSTERED_SHADING_SET)]] Texture2D<RVec4> g_diffuseDecalTex;
 [[vk::binding(CLUSTERED_SHADING_DECALS_BINDING + 2u, CLUSTERED_SHADING_SET)]] Texture2D<RVec4>
-	u_specularRoughnessDecalTex;
+	g_specularRoughnessDecalTex;
 #endif
 
 //
@@ -65,7 +65,7 @@
 #if defined(CLUSTERED_SHADING_FOG_BINDING)
 [[vk::binding(CLUSTERED_SHADING_FOG_BINDING, CLUSTERED_SHADING_SET)]] cbuffer b_fogDensityVolumes
 {
-	FogDensityVolume u_fogDensityVolumes[kMaxVisibleFogDensityVolumes];
+	FogDensityVolume g_fogDensityVolumes[kMaxVisibleFogDensityVolumes];
 };
 #endif
 
@@ -74,11 +74,11 @@
 //
 #if defined(CLUSTERED_SHADING_GI_BINDING)
 [[vk::binding(CLUSTERED_SHADING_GI_BINDING, CLUSTERED_SHADING_SET)]] Texture3D<RVec4>
-	u_globalIlluminationTextures[kMaxVisibleGlobalIlluminationProbes];
+	g_globalIlluminationTextures[kMaxVisibleGlobalIlluminationProbes];
 
 [[vk::binding(CLUSTERED_SHADING_GI_BINDING + 1u, CLUSTERED_SHADING_SET)]] cbuffer b_giProbes
 {
-	GlobalIlluminationProbe u_giProbes[kMaxVisibleGlobalIlluminationProbes];
+	GlobalIlluminationProbe g_giProbes[kMaxVisibleGlobalIlluminationProbes];
 };
 #endif
 
@@ -86,7 +86,7 @@
 // Cluster uniforms
 //
 #if defined(CLUSTERED_SHADING_CLUSTERS_BINDING)
-[[vk::binding(CLUSTERED_SHADING_CLUSTERS_BINDING, CLUSTERED_SHADING_SET)]] StructuredBuffer<Cluster> u_clusters;
+[[vk::binding(CLUSTERED_SHADING_CLUSTERS_BINDING, CLUSTERED_SHADING_SET)]] StructuredBuffer<Cluster> g_clusters;
 #endif
 
 // Debugging function
@@ -175,16 +175,16 @@ Cluster mergeClusters(Cluster tileCluster, Cluster zCluster)
 /// Get the final cluster after ORing and ANDing the masks.
 Cluster getClusterFragCoord(Vec3 fragCoord, U32 tileSize, UVec2 tileCounts, U32 zSplitCount, F32 a, F32 b)
 {
-	const Cluster tileCluster = u_clusters[computeTileClusterIndexFragCoord(fragCoord.xy, tileSize, tileCounts.x)];
+	const Cluster tileCluster = g_clusters[computeTileClusterIndexFragCoord(fragCoord.xy, tileSize, tileCounts.x)];
 	const Cluster zCluster =
-		u_clusters[computeZSplitClusterIndex(fragCoord.z, zSplitCount, a, b) + tileCounts.x * tileCounts.y];
+		g_clusters[computeZSplitClusterIndex(fragCoord.z, zSplitCount, a, b) + tileCounts.x * tileCounts.y];
 	return mergeClusters(tileCluster, zCluster);
 }
 
 Cluster getClusterFragCoord(Vec3 fragCoord)
 {
-	return getClusterFragCoord(fragCoord, u_clusteredShading.m_tileSize, u_clusteredShading.m_tileCounts,
-							   u_clusteredShading.m_zSplitCount, u_clusteredShading.m_zSplitMagic.x,
-							   u_clusteredShading.m_zSplitMagic.y);
+	return getClusterFragCoord(fragCoord, g_clusteredShading.m_tileSize, g_clusteredShading.m_tileCounts,
+							   g_clusteredShading.m_zSplitCount, g_clusteredShading.m_zSplitMagic.x,
+							   g_clusteredShading.m_zSplitMagic.y);
 }
 #endif

AnKi/Shaders/FinalComposite.ankiprog

@@ -21,17 +21,17 @@ ANKI_SPECIALIZATION_CONSTANT_U32(kLutSize, 0u);
 ANKI_SPECIALIZATION_CONSTANT_UVEC2(kFramebufferSize, 1u);
 ANKI_SPECIALIZATION_CONSTANT_U32(kMotionBlurSamples, 3u);
 
-[[vk::binding(0)]] SamplerState u_nearestAnyClampSampler;
-[[vk::binding(1)]] SamplerState u_linearAnyClampSampler;
-[[vk::binding(2)]] SamplerState u_trilinearRepeatSampler;
-
-[[vk::binding(3)]] Texture2D<RVec4> u_lightShadingRt;
-[[vk::binding(4)]] Texture2D<RVec4> u_ppsBloomLfRt;
-[[vk::binding(5)]] Texture3D<RVec4> u_lut;
-[[vk::binding(6)]] Texture2D u_motionVectorsRt;
-[[vk::binding(7)]] Texture2D u_depthRt;
+[[vk::binding(0)]] SamplerState g_nearestAnyClampSampler;
+[[vk::binding(1)]] SamplerState g_linearAnyClampSampler;
+[[vk::binding(2)]] SamplerState g_trilinearRepeatSampler;
+
+[[vk::binding(3)]] Texture2D<RVec4> g_lightShadingRt;
+[[vk::binding(4)]] Texture2D<RVec4> g_ppsBloomLfRt;
+[[vk::binding(5)]] Texture3D<RVec4> g_lut;
+[[vk::binding(6)]] Texture2D g_motionVectorsRt;
+[[vk::binding(7)]] Texture2D g_depthRt;
 #if DBG_ENABLED
-[[vk::binding(8)]] Texture2D<RVec4> u_dbgOutlineRt;
+[[vk::binding(8)]] Texture2D<RVec4> g_dbgOutlineRt;
 #endif
 
 struct PushConstants
@@ -41,7 +41,7 @@ struct PushConstants
 	U32 m_frameCount;
 };
 
-[[vk::push_constant]] ConstantBuffer<PushConstants> u_pc;
+[[vk::push_constant]] ConstantBuffer<PushConstants> g_pc;
 
 struct VertOut
 {
@@ -61,7 +61,7 @@ RVec3 colorGrading(RVec3 color)
 
 	color = min(color, RVec3(1.0, 1.0, 1.0));
 	const RVec3 lutCoords = color * kLutScale + kLutOffset;
-	return u_lut.SampleLevel(u_trilinearRepeatSampler, lutCoords, 0.0).rgb;
+	return g_lut.SampleLevel(g_trilinearRepeatSampler, lutCoords, 0.0).rgb;
 }
 
 FragOut main(VertOut input)
@@ -71,16 +71,16 @@ FragOut main(VertOut input)
 
 	if(kMotionBlurSamples > 0u)
 	{
-		outColor = motionBlur(u_motionVectorsRt, u_nearestAnyClampSampler, u_lightShadingRt, Vec2(kFramebufferSize),
-							  u_linearAnyClampSampler, uv, kMotionBlurSamples);
+		outColor = motionBlur(g_motionVectorsRt, g_nearestAnyClampSampler, g_lightShadingRt, Vec2(kFramebufferSize),
+							  g_linearAnyClampSampler, uv, kMotionBlurSamples);
 	}
 	else
 	{
-		outColor = u_lightShadingRt.SampleLevel(u_linearAnyClampSampler, uv, 0.0).rgb;
+		outColor = g_lightShadingRt.SampleLevel(g_linearAnyClampSampler, uv, 0.0).rgb;
 	}
 
 #if BLOOM_ENABLED
-	const RVec3 bloom = u_ppsBloomLfRt.SampleLevel(u_linearAnyClampSampler, uv, 0.0).rgb;
+	const RVec3 bloom = g_ppsBloomLfRt.SampleLevel(g_linearAnyClampSampler, uv, 0.0).rgb;
 	outColor += bloom;
 #endif
 
@@ -88,11 +88,11 @@ FragOut main(VertOut input)
 
 #if FILM_GRAIN
 	const F32 dt = 1.0;
-	outColor = filmGrain(outColor, uv, u_pc.m_filmGrainStrength, (F32)(u_pc.m_frameCount % 0xFFFFu) * dt);
+	outColor = filmGrain(outColor, uv, g_pc.m_filmGrainStrength, (F32)(g_pc.m_frameCount % 0xFFFFu) * dt);
 #endif
 
 #if DBG_ENABLED
-	const RVec4 dbg = u_dbgOutlineRt.SampleLevel(u_linearAnyClampSampler, uv, 0.0);
+	const RVec4 dbg = g_dbgOutlineRt.SampleLevel(g_linearAnyClampSampler, uv, 0.0);
 	outColor = lerp(outColor, dbg.rgb, dbg.a);
 #endif
 

AnKi/Shaders/ForwardShadingCommon.hlsl

@@ -17,10 +17,10 @@ ANKI_BINDLESS_SET(kMaterialSetBindless)
 //
 #if defined(ANKI_FRAGMENT_SHADER)
 // Global resources
-[[vk::binding(kMaterialBindingLinearClampSampler, kMaterialSetGlobal)]] SamplerState u_linearAnyClampSampler;
-[[vk::binding(kMaterialBindingDepthRt, kMaterialSetGlobal)]] Texture2D u_gbufferDepthRt;
-[[vk::binding(kMaterialBindingLightVolume, kMaterialSetGlobal)]] Texture3D<RVec4> u_lightVol;
-[[vk::binding(kMaterialBindingShadowSampler, kMaterialSetGlobal)]] SamplerComparisonState u_shadowSampler;
+[[vk::binding(kMaterialBindingLinearClampSampler, kMaterialSetGlobal)]] SamplerState g_linearAnyClampSampler;
+[[vk::binding(kMaterialBindingDepthRt, kMaterialSetGlobal)]] Texture2D g_gbufferDepthTex;
+[[vk::binding(kMaterialBindingLightVolume, kMaterialSetGlobal)]] Texture3D<RVec4> g_lightVol;
+[[vk::binding(kMaterialBindingShadowSampler, kMaterialSetGlobal)]] SamplerComparisonState g_shadowSampler;
 #	define CLUSTERED_SHADING_SET kMaterialSetGlobal
 #	define CLUSTERED_SHADING_UNIFORMS_BINDING kMaterialBindingClusterShadingUniforms
 #	define CLUSTERED_SHADING_LIGHTS_BINDING kMaterialBindingClusterShadingLights
@@ -62,7 +62,7 @@ Vec3 computeLightColorHigh(Vec3 diffCol, Vec3 worldPos, Vec4 svPosition)
 	{
 		const I32 idx = firstbitlow2(cluster.m_pointLightsMask);
 		cluster.m_pointLightsMask &= ~((ExtendedClusterObjectMask)1 << (ExtendedClusterObjectMask)idx);
-		const PointLight light = u_pointLights2[idx];
+		const PointLight light = g_pointLights[idx];
 
 		const Vec3 diffC = diffCol * light.m_diffuseColor;
 
@@ -75,7 +75,7 @@ Vec3 computeLightColorHigh(Vec3 diffCol, Vec3 worldPos, Vec4 svPosition)
 		F32 shadow = 1.0;
 		if(light.m_shadowAtlasTileScale >= 0.0)
 		{
-			shadow = computeShadowFactorPointLight(light, frag2Light, u_shadowAtlasTex, u_shadowSampler);
+			shadow = computeShadowFactorPointLight(light, frag2Light, g_shadowAtlasTex, g_shadowSampler);
 		}
 #	endif
 
@@ -87,7 +87,7 @@ Vec3 computeLightColorHigh(Vec3 diffCol, Vec3 worldPos, Vec4 svPosition)
 	{
 		const I32 idx = firstbitlow2(cluster.m_spotLightsMask);
 		cluster.m_spotLightsMask &= ~((ExtendedClusterObjectMask)1 << (ExtendedClusterObjectMask)idx);
-		const SpotLight light = u_spotLights[idx];
+		const SpotLight light = g_spotLights[idx];
 
 		const Vec3 diffC = diffCol * light.m_diffuseColor;
 
@@ -104,7 +104,7 @@ Vec3 computeLightColorHigh(Vec3 diffCol, Vec3 worldPos, Vec4 svPosition)
 		F32 shadow = 1.0;
 		[[branch]] if(light.m_shadowLayer != kMaxU32)
 		{
-			shadow = computeShadowFactorSpotLight(light, worldPos, u_shadowAtlasTex, u_shadowSampler);
+			shadow = computeShadowFactorSpotLight(light, worldPos, g_shadowAtlasTex, g_shadowSampler);
 		}
 #	endif
 
@@ -119,13 +119,13 @@ RVec3 computeLightColorLow(RVec3 diffCol, RVec3 worldPos, Vec4 svPosition)
 {
 	ANKI_MAYBE_UNUSED(worldPos);
 
-	const Vec2 uv = svPosition.xy / u_clusteredShading.m_renderingSize;
-	const F32 linearDepth = linearizeDepth(svPosition.z, u_clusteredShading.m_near, u_clusteredShading.m_far);
+	const Vec2 uv = svPosition.xy / g_clusteredShading.m_renderingSize;
+	const F32 linearDepth = linearizeDepth(svPosition.z, g_clusteredShading.m_near, g_clusteredShading.m_far);
 	const F32 w =
-		linearDepth * (F32(u_clusteredShading.m_zSplitCount) / F32(u_clusteredShading.m_lightVolumeLastZSplit + 1u));
+		linearDepth * (F32(g_clusteredShading.m_zSplitCount) / F32(g_clusteredShading.m_lightVolumeLastZSplit + 1u));
 	const Vec3 uvw = Vec3(uv, w);
 
-	const RVec3 light = u_lightVol.SampleLevel(u_linearAnyClampSampler, uvw, 0.0).rgb;
+	const RVec3 light = g_lightVol.SampleLevel(g_linearAnyClampSampler, uvw, 0.0).rgb;
 	return diffuseLobe(diffCol) * light;
 }
 
@@ -137,14 +137,14 @@ void particleAlpha(RVec4 color, RVec4 scaleColor, RVec4 biasColor, out FragOut o
 void fog(RVec3 color, RF32 fogAlphaScale, RF32 fogDistanceOfMaxThikness, F32 zVSpace, Vec2 svPosition,
 		 out FragOut output)
 {
-	const Vec2 screenSize = 1.0 / u_clusteredShading.m_renderingSize;
+	const Vec2 screenSize = 1.0 / g_clusteredShading.m_renderingSize;
 
 	const Vec2 texCoords = svPosition * screenSize;
-	const F32 depth = u_gbufferDepthRt.Sample(u_linearAnyClampSampler, texCoords, 0.0).r;
+	const F32 depth = g_gbufferDepthTex.Sample(g_linearAnyClampSampler, texCoords, 0.0).r;
 	F32 zFeatherFactor;
 
 	const Vec4 fragPosVspace4 =
-		mul(u_clusteredShading.m_matrices.m_invertedProjectionJitter, Vec4(Vec3(uvToNdc(texCoords), depth), 1.0));
+		mul(g_clusteredShading.m_matrices.m_invertedProjectionJitter, Vec4(Vec3(uvToNdc(texCoords), depth), 1.0));
 	const F32 sceneZVspace = fragPosVspace4.z / fragPosVspace4.w;
 
 	const F32 diff = max(0.0, zVSpace - sceneZVspace);

AnKi/Shaders/ForwardShadingParticles.ankiprog

@@ -36,11 +36,11 @@ struct VertOut
 #pragma anki struct end
 
 [[vk::binding(kMaterialBindingGlobalUniforms, kMaterialSetGlobal)]] ConstantBuffer<MaterialGlobalUniforms>
-	u_ankiGlobals;
-[[vk::binding(kMaterialBindingTrilinearRepeatSampler, kMaterialSetGlobal)]] SamplerState u_globalSampler;
-[[vk::binding(kMaterialBindingLocalUniforms, kMaterialSetLocal)]] StructuredBuffer<U32> u_localUniforms;
+	g_ankiGlobals;
+[[vk::binding(kMaterialBindingTrilinearRepeatSampler, kMaterialSetGlobal)]] SamplerState g_globalSampler;
+[[vk::binding(kMaterialBindingLocalUniforms, kMaterialSetLocal)]] StructuredBuffer<U32> g_localUniforms;
 [[vk::binding(kMaterialBindingRenderableGpuView, kMaterialSetLocal)]] StructuredBuffer<RenderableGpuView>
-	u_renderableGpuViews;
+	g_renderableGpuViews;
 
 #pragma anki start vert
 
@@ -50,11 +50,11 @@ VertOut main(VertIn input)
 
 	output.m_uv = Vec2(input.m_vertexId & 1, input.m_vertexId >> 1);
 
-	output.m_worldPos = transform(u_ankiGlobals.m_cameraTransform, Vec4((output.m_uv - 0.5) * input.m_scale, 0.0, 0.0))
+	output.m_worldPos = transform(g_ankiGlobals.m_cameraTransform, Vec4((output.m_uv - 0.5) * input.m_scale, 0.0, 0.0))
 						+ input.m_position;
 
-	output.m_svPosition = Vec4(transform(u_renderableGpuViews[0].m_worldTransform, Vec4(output.m_worldPos, 1.0)), 1.0);
-	output.m_svPosition = mul(u_ankiGlobals.m_viewProjectionMatrix, output.m_svPosition);
+	output.m_svPosition = Vec4(transform(g_renderableGpuViews[0].m_worldTransform, Vec4(output.m_worldPos, 1.0)), 1.0);
+	output.m_svPosition = mul(g_ankiGlobals.m_viewProjectionMatrix, output.m_svPosition);
 
 	output.m_alpha = input.m_alpha;
 
@@ -67,13 +67,13 @@ VertOut main(VertIn input)
 FragOut main(VertOut input)
 {
 	FragOut output = (FragOut)0;
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(u_localUniforms, 0u);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_localUniforms, 0u);
 
 #if ANIMATED_TEXTURE == 1
-	RVec4 texCol = readAnimatedTextureRgba(u_bindlessTextures2dArrayF32[localUniforms.m_diffuseMap], u_globalSampler,
-										   localUniforms.m_animationPeriod, input.m_uv, u_clusteredShading.m_time);
+	RVec4 texCol = readAnimatedTextureRgba(g_bindlessTextures2dArrayF32[localUniforms.m_diffuseMap], g_globalSampler,
+										   localUniforms.m_animationPeriod, input.m_uv, g_clusteredShading.m_time);
 #else
-	RVec4 texCol = u_bindlessTextures2dF32[localUniforms.m_diffuseMap].Sample(u_globalSampler, input.m_uv);
+	RVec4 texCol = g_bindlessTextures2dF32[localUniforms.m_diffuseMap].Sample(g_globalSampler, input.m_uv);
 #endif
 
 #if LIGHT

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -40,17 +40,17 @@
 
 ANKI_BINDLESS_SET(kMaterialSetBindless)
 
-[[vk::binding(kMaterialBindingTrilinearRepeatSampler, kMaterialSetGlobal)]] SamplerState u_globalSampler;
-[[vk::binding(kMaterialBindingLocalUniforms, kMaterialSetLocal)]] StructuredBuffer<U32> u_localUniforms;
+[[vk::binding(kMaterialBindingTrilinearRepeatSampler, kMaterialSetGlobal)]] SamplerState g_globalSampler;
+[[vk::binding(kMaterialBindingLocalUniforms, kMaterialSetLocal)]] StructuredBuffer<U32> g_localUniforms;
 [[vk::binding(kMaterialBindingRenderableGpuView, kMaterialSetLocal)]] StructuredBuffer<RenderableGpuView>
-	u_renderableGpuViews;
+	g_renderableGpuViews;
 [[vk::binding(kMaterialBindingGlobalUniforms, kMaterialSetGlobal)]] ConstantBuffer<MaterialGlobalUniforms>
-	u_globalUniforms;
+	g_globalUniforms;
 
 #if ANKI_BONES
-[[vk::binding(kMaterialBindingBoneTransforms, kMaterialSetLocal)]] StructuredBuffer<Mat4> u_boneTransforms;
+[[vk::binding(kMaterialBindingBoneTransforms, kMaterialSetLocal)]] StructuredBuffer<Mat4> g_boneTransforms;
 [[vk::binding(kMaterialBindingPreviousBoneTransforms, kMaterialSetLocal)]] StructuredBuffer<Mat4>
-	u_prevFrameBoneTransforms;
+	g_prevFrameBoneTransforms;
 #endif
 
 #pragma anki reflect AnKiLocalUniforms
@@ -133,12 +133,12 @@ struct FragOut
 #if ANKI_BONES
 void skinning(VertIn input, inout Vec3 pos, inout Vec3 prevPos, inout RVec3 normal, inout RVec4 tangent)
 {
-	Mat4 skinMat = u_boneTransforms[input.m_boneIndices[0]] * input.m_boneWeights[0];
-	Mat4 prevSkinMat = u_prevFrameBoneTransforms[input.m_boneIndices[0]] * input.m_boneWeights[0];
+	Mat4 skinMat = g_boneTransforms[input.m_boneIndices[0]] * input.m_boneWeights[0];
+	Mat4 prevSkinMat = g_prevFrameBoneTransforms[input.m_boneIndices[0]] * input.m_boneWeights[0];
 	[[unroll]] for(U32 i = 1u; i < 4u; ++i)
 	{
-		skinMat += u_boneTransforms[input.m_boneIndices[i]] * input.m_boneWeights[i];
-		prevSkinMat += u_prevFrameBoneTransforms[input.m_boneIndices[i]] * input.m_boneWeights[i];
+		skinMat += g_boneTransforms[input.m_boneIndices[i]] * input.m_boneWeights[i];
+		prevSkinMat += g_prevFrameBoneTransforms[input.m_boneIndices[i]] * input.m_boneWeights[i];
 	}
 
 #	if ANKI_TECHNIQUE == ANKI_RENDERING_TECHNIQUE_GBUFFER
@@ -166,7 +166,7 @@ void velocity(RenderableGpuView view, Vec3 prevLocalPos, inout VertOut output)
 #	endif
 
 	Vec4 v4 = Vec4(transform(trf, Vec4(prevLocalPos, 1.0)), 1.0);
-	v4 = mul(u_globalUniforms.m_previousViewProjectionMatrix, v4);
+	v4 = mul(g_globalUniforms.m_previousViewProjectionMatrix, v4);
 
 	output.m_prevClipXyw = v4.xyw;
 	output.m_crntClipXyw = output.m_position.xyw;
@@ -175,7 +175,7 @@ void velocity(RenderableGpuView view, Vec3 prevLocalPos, inout VertOut output)
 
 VertOut main(VertIn input)
 {
-	const RenderableGpuView view = u_renderableGpuViews[input.m_instanceId];
+	const RenderableGpuView view = g_renderableGpuViews[input.m_instanceId];
 	VertOut output;
 
 	// All values in local space
@@ -209,7 +209,7 @@ VertOut main(VertIn input)
 #endif
 
 	output.m_position = Vec4(transform(view.m_worldTransform, Vec4(pos, 1.0)), 1.0);
-	output.m_position = mul(u_globalUniforms.m_viewProjectionMatrix, output.m_position);
+	output.m_position = mul(g_globalUniforms.m_viewProjectionMatrix, output.m_position);
 
 #if ANKI_TECHNIQUE == ANKI_RENDERING_TECHNIQUE_GBUFFER
 	output.m_normal = transform(view.m_worldTransform, Vec4(normal, 0.0));
@@ -241,8 +241,8 @@ void main(VertOut input)
 {
 	ANKI_MAYBE_UNUSED(input);
 #	if REALLY_ALPHA_TEST
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(u_localUniforms, 0u);
-	const RVec4 diffColorA = u_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(u_globalSampler, input.m_uv);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_localUniforms, 0u);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, input.m_uv);
 	doAlphaTest(diffColorA.a);
 #	endif
 }
@@ -251,8 +251,8 @@ FragOut main(VertOut input)
 {
 	ANKI_MAYBE_UNUSED(input);
 #	if REALLY_ALPHA_TEST
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(u_localUniforms, 0u);
-	const RVec4 diffColorA = u_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(u_globalSampler, input.m_uv);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_localUniforms, 0u);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, input.m_uv);
 	doAlphaTest(diffColorA.a);
 #	endif
 	return (FragOut)0;
@@ -278,7 +278,7 @@ RVec3 readNormalFromTexture(VertOut input, Texture2D<RVec4> map, SamplerState sa
 
 FragOut main(VertOut input)
 {
-	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(u_localUniforms, 0u);
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_localUniforms, 0u);
 
 #	if REALLY_USING_PARALLAX
 	// TODO
@@ -290,43 +290,43 @@ FragOut main(VertOut input)
 
 #	if DIFFUSE_TEX
 #		if REALLY_ALPHA_TEST
-	const RVec4 diffColorA = u_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(u_globalSampler, uv);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, uv);
 	doAlphaTest(diffColorA.a);
 	const RVec3 diffColor = diffColorA.rgb;
 #		else
-	const RVec3 diffColor = u_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(u_globalSampler, uv).rgb;
+	const RVec3 diffColor = g_bindlessTextures2dF32[localUniforms.m_diffTex].Sample(g_globalSampler, uv).rgb;
 #		endif
 #	else
 	const RVec3 diffColor = localUniforms.m_diffColor;
 #	endif
 
 #	if SPECULAR_TEX
-	const RVec3 specColor = u_bindlessTextures2dF32[localUniforms.m_specTex].Sample(u_globalSampler, uv).rgb;
+	const RVec3 specColor = g_bindlessTextures2dF32[localUniforms.m_specTex].Sample(g_globalSampler, uv).rgb;
 #	else
 	const RVec3 specColor = localUniforms.m_specColor;
 #	endif
 
 #	if ROUGHNESS_TEX
-	const RF32 roughness = u_bindlessTextures2dF32[localUniforms.m_roughnessTex].Sample(u_globalSampler, uv).g;
+	const RF32 roughness = g_bindlessTextures2dF32[localUniforms.m_roughnessTex].Sample(g_globalSampler, uv).g;
 #	else
 	const RF32 roughness = localUniforms.m_roughness;
 #	endif
 
 #	if METAL_TEX
-	const RF32 metallic = u_bindlessTextures2dF32[localUniforms.m_metallicTex].Sample(u_globalSampler, uv).b;
+	const RF32 metallic = g_bindlessTextures2dF32[localUniforms.m_metallicTex].Sample(g_globalSampler, uv).b;
 #	else
 	const RF32 metallic = localUniforms.m_metallic;
 #	endif
 
 #	if NORMAL_TEX
 	const RVec3 normal =
-		readNormalFromTexture(input, u_bindlessTextures2dF32[localUniforms.m_normalTex], u_globalSampler, uv);
+		readNormalFromTexture(input, g_bindlessTextures2dF32[localUniforms.m_normalTex], g_globalSampler, uv);
 #	else
 	const RVec3 normal = normalize(input.m_normal);
 #	endif
 
 #	if EMISSIVE_TEX
-	const RVec3 emission = u_bindlessTextures2dF32[localUniforms.m_emissiveTex].Sample(u_globalSampler, uv).rgb;
+	const RVec3 emission = g_bindlessTextures2dF32[localUniforms.m_emissiveTex].Sample(g_globalSampler, uv).rgb;
 #	else
 	const RVec3 emission = localUniforms.m_emission;
 #	endif

AnKi/Shaders/Include/Common.h

@@ -68,11 +68,11 @@ void maybeUnused(T a)
 #	define ANKI_CONCATENATE(a, b) _ANKI_CONCATENATE(a, b)
 
 #	define ANKI_BINDLESS_SET(s) \
-		[[vk::binding(0, s)]] Texture2D<uint4> u_bindlessTextures2dU32[kMaxBindlessTextures]; \
-		[[vk::binding(0, s)]] Texture2D<int4> u_bindlessTextures2dI32[kMaxBindlessTextures]; \
-		[[vk::binding(0, s)]] Texture2D<RVec4> u_bindlessTextures2dF32[kMaxBindlessTextures]; \
-		[[vk::binding(0, s)]] Texture2DArray<RVec4> u_bindlessTextures2dArrayF32[kMaxBindlessTextures]; \
-		[[vk::binding(1, s)]] Buffer<float4> u_bindlessTextureBuffersF32[kMaxBindlessReadonlyTextureBuffers];
+		[[vk::binding(0, s)]] Texture2D<uint4> g_bindlessTextures2dU32[kMaxBindlessTextures]; \
+		[[vk::binding(0, s)]] Texture2D<int4> g_bindlessTextures2dI32[kMaxBindlessTextures]; \
+		[[vk::binding(0, s)]] Texture2D<RVec4> g_bindlessTextures2dF32[kMaxBindlessTextures]; \
+		[[vk::binding(0, s)]] Texture2DArray<RVec4> g_bindlessTextures2dArrayF32[kMaxBindlessTextures]; \
+		[[vk::binding(1, s)]] Buffer<float4> g_bindlessTextureBuffersF32[kMaxBindlessReadonlyTextureBuffers];
 
 #	define _ANKI_SCONST_X(type, n, id) [[vk::constant_id(id)]] const type n = (type)1;
 

AnKi/Shaders/TonemappingResources.hlsl

@@ -0,0 +1,22 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+// Tonemapping resources
+
+#pragma once
+
+#include <AnKi/Shaders/Common.hlsl>
+
+[[vk::binding(kTonemappingBinding)]] globallycoherent RWTexture2D<RVec4> g_tonemappingUav;
+
+void writeExposureAndAverageLuminance(RF32 exposure, RF32 avgLuminance)
+{
+	g_tonemappingUav[UVec2(0, 0)] = Vec4(exposure, avgLuminance, 0.0f, 0.0f);
+}
+
+RVec2 readExposureAndAverageLuminance()
+{
+	return g_tonemappingUav[UVec2(0, 0)].xy;
+}