Fix some GL bugs

shaders/FinalComposite.glslp

@@ -78,7 +78,7 @@ void main()
 
 #if 0
 	{
-		out_color = Vec3(textureLod(u_isRt, uv, 0.0).rgb);
+		out_color = Vec3(u_averageLuminance / 1.0);
 	}
 #endif
 

shaders/TonemappingAverageLuminance.glslp

@@ -11,29 +11,34 @@
 #include <shaders/Common.glsl>
 #include <shaders/Tonemapping.glsl>
 
-const U32 WORKGROUP_SIZE_X = 16u;
-const U32 WORKGROUP_SIZE_Y = 16u;
-const U32 WORKGROUP_SIZE = WORKGROUP_SIZE_X * WORKGROUP_SIZE_Y;
+const UVec2 PREFERABLE_WG_SIZE = UVec2(32u, 32u);
 
-layout(local_size_x = WORKGROUP_SIZE_X, local_size_y = WORKGROUP_SIZE_Y, local_size_z = 1) in;
+// Find a WG size that is dividable to the input tex size
+const UVec2 WORKGROUP_SIZE = INPUT_TEX_SIZE / ((INPUT_TEX_SIZE + PREFERABLE_WG_SIZE - 1u) / PREFERABLE_WG_SIZE);
+const U32 WG_SIZE = WORKGROUP_SIZE.x * WORKGROUP_SIZE.y;
 
-const U32 PIXEL_READ_X = INPUT_TEX_SIZE.x / WORKGROUP_SIZE_X;
-const U32 PIXEL_READ_Y = INPUT_TEX_SIZE.y / WORKGROUP_SIZE_Y;
+const UVec2 TRIMMED_INPUT_TEX_SIZE = (INPUT_TEX_SIZE / WORKGROUP_SIZE) * WORKGROUP_SIZE;
+
+layout(local_size_x = WORKGROUP_SIZE.x, local_size_y = WORKGROUP_SIZE.y, local_size_z = 1) in;
 
 layout(ANKI_TEX_BINDING(0, 0)) uniform sampler2D u_tex;
 
 #define TONEMAPPING_RESOURCE_AS_BUFFER 1
 #include <shaders/TonemappingResources.glsl>
 
-shared F32 s_avgLum[WORKGROUP_SIZE];
+shared F32 s_avgLum[WG_SIZE];
 
 void main()
 {
-	// Gather the log-average luminance of a tile
-	F32 avgLum = 0.0;
+	// Gather the log-average luminance of a tile. It will miss some pixels but not too many
+	const U32 PIXEL_READ_X = TRIMMED_INPUT_TEX_SIZE.x / WORKGROUP_SIZE.x;
+	const U32 PIXEL_READ_Y = TRIMMED_INPUT_TEX_SIZE.y / WORKGROUP_SIZE.y;
+
 	U32 yStart = gl_LocalInvocationID.y * PIXEL_READ_Y;
 	U32 xStart = gl_LocalInvocationID.x * PIXEL_READ_X;
-	ANKI_LOOP for(U32 y = 0; y < PIXEL_READ_Y; ++y)
+
+	F32 avgLum = 0.0;
+	ANKI_UNROLL for(U32 y = 0; y < PIXEL_READ_Y; ++y)
 	{
 		ANKI_UNROLL for(U32 x = 0; x < PIXEL_READ_X; ++x)
 		{
@@ -54,7 +59,7 @@ void main()
 	barrier();
 
 	// Gather the results into one
-	ANKI_LOOP for(U32 s = WORKGROUP_SIZE / 2u; s > 0u; s >>= 1u)
+	ANKI_LOOP for(U32 s = WG_SIZE / 2u; s > 0u; s >>= 1u)
 	{
 		if(gl_LocalInvocationIndex < s)
 		{
@@ -66,12 +71,12 @@ void main()
 	}
 
 	// Write the result
-	ANKI_BRANCH if(gl_LocalInvocationIndex == 0)
+	ANKI_BRANCH if(gl_LocalInvocationIndex == 0u)
 	{
 #if LOG_AVG
-		F32 crntLum = exp(s_avgLum[0] * (1.0 / F32(INPUT_TEX_SIZE.x * INPUT_TEX_SIZE.y)));
+		F32 crntLum = exp(s_avgLum[0] * (1.0 / F32(TRIMMED_INPUT_TEX_SIZE.x * TRIMMED_INPUT_TEX_SIZE.y)));
 #else
-		F32 crntLum = s_avgLum[0] * (1.0 / F32(INPUT_TEX_SIZE.x * INPUT_TEX_SIZE.y));
+		F32 crntLum = s_avgLum[0] * (1.0 / F32(TRIMMED_INPUT_TEX_SIZE.x * TRIMMED_INPUT_TEX_SIZE.y));
 #endif
 
 #if 1

src/anki/gr/gl/CommandBuffer.cpp

@@ -741,7 +741,7 @@ void CommandBuffer::bindImage(U32 set, U32 binding, TextureViewPtr img)
 
 			glBindImageTexture(m_unit,
 				view.m_view.m_glName,
-				m_img->getSubresource().m_firstMipmap,
+				0,
 				GL_TRUE,
 				0,
 				GL_READ_WRITE,
@@ -1376,19 +1376,76 @@ void CommandBuffer::setBufferBarrier(
 void CommandBuffer::setTextureSurfaceBarrier(
 	TexturePtr tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage, const TextureSurfaceInfo& surf)
 {
-	// Do nothing
+	TextureSubresourceInfo subresource;
+	setTextureBarrier(tex, prevUsage, nextUsage, subresource);
 }
 
 void CommandBuffer::setTextureVolumeBarrier(
 	TexturePtr tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage, const TextureVolumeInfo& vol)
 {
-	// Do nothing
+	TextureSubresourceInfo subresource;
+	setTextureBarrier(tex, prevUsage, nextUsage, subresource);
 }
 
 void CommandBuffer::setTextureBarrier(
 	TexturePtr tex, TextureUsageBit prevUsage, TextureUsageBit nextUsage, const TextureSubresourceInfo& subresource)
 {
-	// Do nothing for GL
+	class Cmd final : public GlCommand
+	{
+	public:
+		GLenum m_barrier;
+
+		Cmd(GLenum barrier)
+			: m_barrier(barrier)
+		{
+		}
+
+		Error operator()(GlState&)
+		{
+			glMemoryBarrier(m_barrier);
+			return Error::NONE;
+		}
+	};
+
+	const TextureUsageBit usage = nextUsage;
+	GLenum e = 0;
+
+	if(!!(usage & TextureUsageBit::SAMPLED_ALL))
+	{
+		e |= GL_TEXTURE_FETCH_BARRIER_BIT;
+	}
+
+	if(!!(usage & TextureUsageBit::IMAGE_ALL))
+	{
+		e |= GL_SHADER_IMAGE_ACCESS_BARRIER_BIT;
+	}
+
+	if(!!(usage & TextureUsageBit::TRANSFER_DESTINATION))
+	{
+		e |= GL_TEXTURE_UPDATE_BARRIER_BIT;
+	}
+
+	if(!!(usage & TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE))
+	{
+
+		e |= GL_FRAMEBUFFER_BARRIER_BIT;
+	}
+
+	if(!!(usage & TextureUsageBit::CLEAR))
+	{
+		// No idea
+	}
+
+	if(!!(usage & TextureUsageBit::GENERATE_MIPMAPS))
+	{
+		// No idea
+	}
+
+	if(e != 0)
+	{
+		ANKI_GL_SELF(CommandBufferImpl);
+		self.pushBackNewCommand<Cmd>(e);
+	}
 }
 
 void CommandBuffer::clearTextureView(TextureViewPtr texView, const ClearValue& clearValue)

src/anki/renderer/Tonemapping.cpp

@@ -24,8 +24,7 @@ Error Tonemapping::init(const ConfigSet& cfg)
 
 Error Tonemapping::initInternal(const ConfigSet& initializer)
 {
-	m_inputTexMip =
-		computeMaxMipmapCount2d(m_r->getWidth(), m_r->getHeight(), AVERAGE_LUMINANCE_RENDER_TARGET_SIZE) - 1;
+	m_inputTexMip = m_r->getDownscaleBlur().getMipmapCount() - 2;
 
 	// Create program
 	ANKI_CHECK(getResourceManager().loadResource("shaders/TonemappingAverageLuminance.glslp", m_prog));