Start using shader_ballot more

shaders/ClusterLightCommon.glsl

@@ -64,6 +64,14 @@ layout(ANKI_UBO_BINDING(LIGHT_SET, LIGHT_UBO_BINDING), std140, row_major) unifor
 	LightingUniforms u_lightingUniforms;
 };
 
+#define u_near readFirstInvocationARB(u_lightingUniforms.nearFarClustererMagicPad1.x)
+#define u_far readFirstInvocationARB(u_lightingUniforms.nearFarClustererMagicPad1.y)
+#define u_clusterCountX readFirstInvocationARB(u_lightingUniforms.tileCount.x)
+#define u_clusterCountY readFirstInvocationARB(u_lightingUniforms.tileCount.y)
+#define u_clustererMagic readFirstInvocationARB(u_lightingUniforms.nearFarClustererMagicPad1.z)
+#define u_time readFirstInvocationARB(u_lightingUniforms.rendererSizeTimePad1.z)
+#define u_unprojectionParams readFirstInvocationARB(u_lightingUniforms.projectionParams)
+
 #ifdef FRAGMENT_SHADER
 
 layout(ANKI_UBO_BINDING(LIGHT_SET, LIGHT_UBO_BINDING + 1), std140) uniform u1_

shaders/FsCommonFrag.glsl

@@ -20,7 +20,7 @@ layout(ANKI_TEX_BINDING(1, 0)) uniform sampler2D anki_msDepthRt;
 #define LIGHT_TEX_BINDING 1
 #include "shaders/ClusterLightCommon.glsl"
 
-#define anki_u_time u_lightingUniforms.rendererSizeTimePad1.z
+#define anki_u_time u_time
 #define RENDERER_SIZE (u_lightingUniforms.rendererSizeTimePad1.xy * 0.5)
 
 layout(location = 0) flat in float in_alpha;
@@ -121,12 +121,8 @@ vec3 computeLightColor(vec3 diffCol)
 	vec3 fragPos = in_posViewSpace;
 
 	// Find the cluster and then the light counts
-	uint clusterIdx = computeClusterIndex(gl_FragCoord.xy / RENDERER_SIZE,
-		u_lightingUniforms.nearFarClustererMagicPad1.x,
-		u_lightingUniforms.nearFarClustererMagicPad1.z,
-		fragPos.z,
-		u_lightingUniforms.tileCount.x,
-		u_lightingUniforms.tileCount.y);
+	uint clusterIdx = computeClusterIndex(
+		gl_FragCoord.xy / RENDERER_SIZE, u_near, u_far, fragPos.z, u_clusterCountX, u_clusterCountY);
 
 	uint idxOffset = u_clusters[clusterIdx];
 
@@ -234,8 +230,8 @@ void fog(in sampler2D depthMap, in vec3 color, in float fogScale)
 
 	if(depth < 1.0)
 	{
-		float zNear = u_lightingUniforms.nearFarClustererMagicPad1.x;
-		float zFar = u_lightingUniforms.nearFarClustererMagicPad1.y;
+		float zNear = u_near;
+		float zFar = u_far;
 		vec2 linearDepths = (2.0 * zNear) / (zFar + zNear - vec2(depth, gl_FragCoord.z) * (zFar - zNear));
 
 		diff = linearDepths.x - linearDepths.y;

shaders/Is.frag.glsl

@@ -156,10 +156,7 @@ void main()
 	diffCol *= ssao;
 
 	// Get counts and offsets
-	uint clusterIdx =
-		computeClusterK(
-			u_lightingUniforms.nearFarClustererMagicPad1.x, u_lightingUniforms.nearFarClustererMagicPad1.z, fragPos.z)
-			* (CLUSTER_COUNT_X * CLUSTER_COUNT_Y)
+	uint clusterIdx = computeClusterK(u_near, u_clustererMagic, fragPos.z) * (CLUSTER_COUNT_X * CLUSTER_COUNT_Y)
 		+ uint(in_clusterIJ.y) * CLUSTER_COUNT_X + uint(in_clusterIJ.x);
 
 	uint idxOffset = u_clusters[clusterIdx];

shaders/Volumetric.frag.glsl

@@ -26,10 +26,10 @@ layout(std140, ANKI_UBO_BINDING(0, 3), row_major) uniform ubo0_
 	mat4 u_prevViewProjMatMulInvViewProjMat;
 };
 
-#define u_linearize u_linearizeNoiseTexOffsetLayer.xy
-#define u_noiseYOffset u_linearizeNoiseTexOffsetLayer.z
-#define u_noiseLayer u_linearizeNoiseTexOffsetLayer.w
-#define u_fogParticleColor u_fogParticleColorPad1.rgb
+#define u_linearize readFirstInvocationARB(u_linearizeNoiseTexOffsetLayer.xy)
+#define u_noiseYOffset readFirstInvocationARB(u_linearizeNoiseTexOffsetLayer.z)
+#define u_noiseLayer readFirstInvocationARB(u_linearizeNoiseTexOffsetLayer.w)
+#define u_fogParticleColor readFirstInvocationARB(u_fogParticleColorPad1.rgb)
 
 layout(location = 0) out vec3 out_color;
 
@@ -100,8 +100,8 @@ void main()
 	vec3 history = textureLod(u_historyRt, oldUv, 0.0).rgb;
 
 	vec3 farPos;
-	farPos.z = u_lightingUniforms.projectionParams.z / (u_lightingUniforms.projectionParams.w + depth);
-	farPos.xy = ndc.xy * u_lightingUniforms.projectionParams.xy * farPos.z;
+	farPos.z = u_projectionParams.z / (u_projectionParams.w + depth);
+	farPos.xy = ndc.xy * u_projectionParams.xy * farPos.z;
 	vec3 viewDir = normalize(farPos);
 
 	uint i = uint(in_uv.x * float(CLUSTER_COUNT.x));
@@ -115,8 +115,7 @@ void main()
 	vec3 newCol = vec3(0.0);
 	for(uint k = 0u; k < CLUSTER_COUNT.z; ++k)
 	{
-		float kFar = computeClusterFar(
-			k, u_lightingUniforms.nearFarClustererMagicPad1.x, u_lightingUniforms.nearFarClustererMagicPad1.z);
+		float kFar = computeClusterFar(k, u_near, u_clustererMagic);
 
 		//
 		// Compute sample count

src/anki/gr/gl/ShaderImpl.cpp

@@ -46,6 +46,11 @@ static const char* SHADER_HEADER = R"(#version %u %s
 #define ANKI_WRITE_POSITION(x_) gl_Position = x_
 #endif
 
+#if 1
+#extension GL_ARB_shader_ballot : require
+#define ANKI_ARB_SHADER_BALLOT 1
+#endif
+
 %s)";
 
 ShaderImpl::~ShaderImpl()

src/anki/renderer/Is.cpp

@@ -30,7 +30,7 @@ public:
 	Mat4 m_invProjMat;
 };
 
-enum class ShaderVariantBit : U8
+enum class IsShaderVariantBit : U8
 {
 	P_LIGHTS = 1 << 0,
 	S_LIGHTS = 1 << 1,
@@ -39,7 +39,7 @@ enum class ShaderVariantBit : U8
 	P_LIGHTS_SHADOWS = 1 << 4,
 	S_LIGHTS_SHADOWS = 1 << 5
 };
-ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderVariantBit, inline)
+ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(IsShaderVariantBit, inline)
 
 Is::Is(Renderer* r)
 	: RenderingPass(r)
@@ -230,57 +230,4 @@ void Is::setPreRunBarriers(RenderingContext& ctx)
 		TextureSurfaceInfo(0, 0, 0, 0));
 }
 
-Error Is::getOrCreateProgram(ShaderVariantBit variantMask, RenderingContext& ctx, ShaderProgramPtr& prog)
-{
-	auto it = m_shaderVariantMap.find(variantMask);
-	if(it != m_shaderVariantMap.getEnd())
-	{
-		prog = it->m_lightProg;
-	}
-	else
-	{
-		ShaderVariant variant;
-
-		ANKI_CHECK(m_r->createShaderf("shaders/Is.frag.glsl",
-			variant.m_lightFrag,
-			"#define TILE_COUNT_X %u\n"
-			"#define TILE_COUNT_Y %u\n"
-			"#define CLUSTER_COUNT %u\n"
-			"#define RENDERER_WIDTH %u\n"
-			"#define RENDERER_HEIGHT %u\n"
-			"#define MAX_LIGHT_INDICES %u\n"
-			"#define POISSON %u\n"
-			"#define INDIRECT_ENABLED %u\n"
-			"#define IR_MIPMAP_COUNT %u\n"
-			"#define POINT_LIGHTS_ENABLED %u\n"
-			"#define SPOT_LIGHTS_ENABLED %u\n"
-			"#define DECALS_ENABLED %u\n"
-			"#define POINT_LIGHTS_SHADOWS_ENABLED %u\n"
-			"#define SPOT_LIGHTS_SHADOWS_ENABLED %u\n",
-			m_clusterCounts[0],
-			m_clusterCounts[1],
-			m_clusterCount,
-			m_r->getWidth(),
-			m_r->getHeight(),
-			m_maxLightIds,
-			m_r->getSm().m_poissonEnabled,
-			!!(variantMask & ShaderVariantBit::INDIRECT),
-			m_r->getIr().getReflectionTextureMipmapCount(),
-			!!(variantMask & ShaderVariantBit::P_LIGHTS),
-			!!(variantMask & ShaderVariantBit::S_LIGHTS),
-			!!(variantMask & ShaderVariantBit::DECALS),
-			!!(variantMask & ShaderVariantBit::P_LIGHTS_SHADOWS),
-			!!(variantMask & ShaderVariantBit::S_LIGHTS_SHADOWS)));
-
-		variant.m_lightProg =
-			getGrManager().newInstance<ShaderProgram>(m_lightVert->getGrShader(), variant.m_lightFrag->getGrShader());
-
-		prog = variant.m_lightProg;
-
-		m_shaderVariantMap.pushBack(getAllocator(), variantMask, variant);
-	}
-
-	return ErrorCode::NONE;
-}
-
 } // end namespace anki

src/anki/renderer/Is.h

@@ -15,7 +15,6 @@ namespace anki
 // Forward
 class FrustumComponent;
 class LightBin;
-enum class ShaderVariantBit : U8;
 
 /// @addtogroup renderer
 /// @{
@@ -61,27 +60,6 @@ private:
 	ShaderResourcePtr m_lightFrag;
 	ShaderProgramPtr m_lightProg;
 
-	class ShaderVariant
-	{
-	public:
-		ShaderResourcePtr m_lightFrag;
-		ShaderProgramPtr m_lightProg;
-	};
-
-	using Key = ShaderVariantBit;
-
-	/// Hash the hash.
-	class Hasher
-	{
-	public:
-		U64 operator()(const Key& b) const
-		{
-			return U64(b);
-		}
-	};
-
-	HashMap<Key, ShaderVariant, Hasher> m_shaderVariantMap;
-
 	LightBin* m_lightBin = nullptr;
 
 	/// @name Limits
@@ -93,9 +71,6 @@ private:
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
 	void updateCommonBlock(RenderingContext& ctx);
-
-	ANKI_USE_RESULT Error getOrCreateProgram(
-		ShaderVariantBit variantMask, RenderingContext& ctx, ShaderProgramPtr& prog);
 };
 /// @}