GR interface: It builds

src/anki/gr/CommandBuffer.h

@@ -142,10 +142,10 @@ public:
 	/// @{
 
 	/// Bind vertex buffer.
-	void bindVertexBuffer(BufferPtr buff, U32 binding, PtrSize offset, PtrSize stride);
+	void bindVertexBuffer(U32 binding, BufferPtr buff, PtrSize offset, PtrSize stride);
 
 	/// Bind transient vertex buffer.
-	void bindVertexBuffer(BufferPtr buff, U32 binding, const TransientMemoryToken& token);
+	void bindVertexBuffer(U32 binding, const TransientMemoryToken& token, PtrSize stride);
 
 	/// Setup a vertex attribute.
 	void setVertexAttribute(U32 location, U32 buffBinding, const PixelFormat& fmt, PtrSize relativeOffset);
@@ -157,13 +157,13 @@ public:
 	void bindIndexBuffer(const TransientMemoryToken& token, IndexType type);
 
 	/// Enable primitive restart.
-	void enablePrimitiveRestart(Bool enable);
+	void setPrimitiveRestart(Bool enable);
 
 	/// Set the viewport.
 	void setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy);
 
 	/// Enable scissor test.
-	void enableScissorTest(Bool enable);
+	void setScissorTest(Bool enable);
 
 	/// Set the scissor rect.
 	void setScissorRect(U16 minx, U16 miny, U16 maxx, U16 maxy);
@@ -196,13 +196,13 @@ public:
 	void setStencilReference(FaceSelectionMask face, U32 ref);
 
 	/// Enable/disable depth write.
-	void enableDepthWrite(Bool enable);
+	void setDepthWrite(Bool enable);
 
 	/// Set depth compare function.
 	void setDepthCompareFunction(CompareOperation op);
 
 	/// Enable/disable alpha to coverage.
-	void enableAlphaToCoverage(Bool enable);
+	void setAlphaToCoverage(Bool enable);
 
 	/// Set color channel write mask.
 	void setColorChannelWriteMask(U32 attachment, ColorBit mask);

src/anki/gr/Common.h

@@ -173,12 +173,7 @@ enum class TransientMemoryTokenLifetime : U8
 /// Token that gets returned when requesting for memory to write to a resource.
 class TransientMemoryToken
 {
-anki_internal:
-	PtrSize m_offset = 0;
-	PtrSize m_range = 0;
-	TransientMemoryTokenLifetime m_lifetime = TransientMemoryTokenLifetime::PER_FRAME;
-	BufferUsageBit m_usage = BufferUsageBit::NONE;
-
+public:
 	operator Bool() const
 	{
 		return m_offset != 0;
@@ -189,6 +184,12 @@ anki_internal:
 		return m_offset == b.m_offset && m_range == b.m_range && m_lifetime == b.m_lifetime && m_usage == b.m_usage;
 	}
 
+anki_internal:
+	PtrSize m_offset = 0;
+	PtrSize m_range = 0;
+	TransientMemoryTokenLifetime m_lifetime = TransientMemoryTokenLifetime::PER_FRAME;
+	BufferUsageBit m_usage = BufferUsageBit::NONE;
+
 	void markUnused()
 	{
 		m_offset = m_range = MAX_U32;

src/anki/gr/gl/CommandBuffer.cpp

@@ -67,7 +67,7 @@ void CommandBuffer::finish()
 	getManager().getImplementation().getRenderingThread().finishCommandBuffer(CommandBufferPtr(this));
 }
 
-void CommandBuffer::bindVertexBuffer(BufferPtr buff, U32 binding, PtrSize offset, PtrSize stride)
+void CommandBuffer::bindVertexBuffer(U32 binding, BufferPtr buff, PtrSize offset, PtrSize stride)
 {
 	class Cmd final : public GlCommand
 	{
@@ -95,9 +95,33 @@ void CommandBuffer::bindVertexBuffer(BufferPtr buff, U32 binding, PtrSize offset
 	m_impl->pushBackNewCommand<Cmd>(buff, binding, offset, stride);
 }
 
-void CommandBuffer::bindVertexBuffer(BufferPtr buff, U32 binding, const TransientMemoryToken& token)
+void CommandBuffer::bindVertexBuffer(U32 binding, const TransientMemoryToken& token, PtrSize stride)
 {
-	ANKI_ASSERT(!"TODO");
+	class Cmd final : public GlCommand
+	{
+	public:
+		U32 m_binding;
+		TransientMemoryToken m_token;
+		PtrSize m_stride;
+		GLuint m_name;
+
+		Cmd(U32 binding, const TransientMemoryToken& token, PtrSize stride, GLuint name)
+			: m_binding(binding)
+			, m_token(token)
+			, m_stride(stride)
+			, m_name(name)
+		{
+		}
+
+		Error operator()(GlState& state)
+		{
+			glBindVertexBuffer(m_binding, m_name, m_token.m_offset, m_stride);
+			return ErrorCode::NONE;
+		}
+	};
+
+	GLuint name = getManager().getImplementation().getTransientMemoryManager().getGlName(token);
+	m_impl->pushBackNewCommand<Cmd>(binding, token, stride, name);
 }
 
 void CommandBuffer::setVertexAttribute(U32 location, U32 buffBinding, const PixelFormat& fmt, PtrSize relativeOffset)
@@ -170,7 +194,7 @@ void CommandBuffer::bindIndexBuffer(const TransientMemoryToken& token, IndexType
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::enablePrimitiveRestart(Bool enable)
+void CommandBuffer::setPrimitiveRestart(Bool enable)
 {
 	class Cmd final : public GlCommand
 	{
@@ -197,7 +221,7 @@ void CommandBuffer::enablePrimitiveRestart(Bool enable)
 		}
 	};
 
-	m_impl->m_state.enablePrimitiveRestart(enable, [=]() { m_impl->pushBackNewCommand<Cmd>(enable); });
+	m_impl->m_state.setPrimitiveRestart(enable, [=]() { m_impl->pushBackNewCommand<Cmd>(enable); });
 }
 
 void CommandBuffer::setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy)
@@ -397,7 +421,7 @@ void CommandBuffer::setStencilReference(FaceSelectionMask face, U32 ref)
 	m_impl->m_state.setStencilReference(face, ref);
 }
 
-void CommandBuffer::enableDepthWrite(Bool enable)
+void CommandBuffer::setDepthWrite(Bool enable)
 {
 	class Cmd final : public GlCommand
 	{
@@ -417,7 +441,7 @@ void CommandBuffer::enableDepthWrite(Bool enable)
 		}
 	};
 
-	m_impl->m_state.enableDepthWrite(enable, [=]() { m_impl->pushBackNewCommand<Cmd>(enable); });
+	m_impl->m_state.setDepthWrite(enable, [=]() { m_impl->pushBackNewCommand<Cmd>(enable); });
 }
 
 void CommandBuffer::setDepthCompareFunction(CompareOperation op)
@@ -443,7 +467,7 @@ void CommandBuffer::setDepthCompareFunction(CompareOperation op)
 		op, [=]() { m_impl->pushBackNewCommand<Cmd>(convertCompareOperation(op)); });
 }
 
-void CommandBuffer::enableAlphaToCoverage(Bool enable)
+void CommandBuffer::setAlphaToCoverage(Bool enable)
 {
 	ANKI_ASSERT(!"TODO");
 }

src/anki/gr/gl/CommandBufferImpl.cpp

@@ -109,7 +109,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 
 		if(m_state.m_primitiveRestart == 2)
 		{
-			cmdb.enablePrimitiveRestart(false);
+			cmdb.setPrimitiveRestart(false);
 		}
 
 		if(m_state.m_fillMode == FillMode::COUNT)
@@ -159,7 +159,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 
 		if(m_state.m_depthWrite == 2)
 		{
-			cmdb.enableDepthWrite(true);
+			cmdb.setDepthWrite(true);
 		}
 
 		if(m_state.m_depthOp == CompareOperation::COUNT)
@@ -276,7 +276,7 @@ void CommandBufferImpl::flushDrawcall(CommandBuffer& cmdb)
 		}
 	};
 
-	m_state.maybeEnableDepthTest([=](Bool enable) { pushBackNewCommand<StencilTestCmd>(enable); });
+	m_state.maybeEnableStencilTest([=](Bool enable) { pushBackNewCommand<StencilTestCmd>(enable); });
 }
 
 } // end namespace anki

src/anki/gr/gl/StateTracker.h

@@ -58,7 +58,7 @@ public:
 	U8 m_primitiveRestart = 2;
 
 	template<typename TFunc>
-	void enablePrimitiveRestart(Bool enable, TFunc func)
+	void setPrimitiveRestart(Bool enable, TFunc func)
 	{
 		U enablei = enable ? 1 : 0;
 		if(enablei != m_primitiveRestart)
@@ -286,7 +286,7 @@ public:
 	Bool8 m_depthWrite = 2;
 
 	template<typename TFunc>
-	void enableDepthWrite(Bool enable, TFunc func)
+	void setDepthWrite(Bool enable, TFunc func)
 	{
 		if(m_depthWrite != enable)
 		{

src/anki/renderer/Bloom.cpp

@@ -45,7 +45,7 @@ Error BloomExposure::init(const ConfigSet& config)
 	m_fb = gr.newInstance<Framebuffer>(fbInit);
 
 	// init shaders
-	ANKI_CHECK(m_r->createShader("shaders/Bloom.frag.glsl",
+	ANKI_CHECK(m_r->createShaderf("shaders/Bloom.frag.glsl",
 		m_frag,
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n"
@@ -89,7 +89,7 @@ void BloomExposure::run(RenderingContext& ctx)
 	*uniforms = Vec4(m_threshold, m_scale, 0.0, 0.0);
 
 	cmdb->bindUniformBuffer(0, 0, token);
-	cmdb->bindStorageBuffer(0, 0, m_r->getTm().getAverageLuminanceBuffer(), 0);
+	cmdb->bindStorageBuffer(0, 0, m_r->getTm().m_luminanceBuff, 0);
 
 	m_r->drawQuad(cmdb);
 	cmdb->endRenderPass();
@@ -124,7 +124,7 @@ Error BloomUpscale::init(const ConfigSet& config)
 	m_fb = gr.newInstance<Framebuffer>(fbInit);
 
 	// init shaders
-	ANKI_CHECK(m_r->createShader("shaders/BloomUpscale.frag.glsl",
+	ANKI_CHECK(m_r->createShaderf("shaders/BloomUpscale.frag.glsl",
 		m_frag,
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n",

src/anki/renderer/DebugDrawer.cpp

@@ -31,38 +31,10 @@ Error DebugDrawer::init(Renderer* r)
 	m_r = r;
 	GrManager& gr = r->getGrManager();
 
-	// Create the pipelines
+	// Create the prog and shaders
 	ANKI_CHECK(r->getResourceManager().loadResource("shaders/Dbg.vert.glsl", m_vert));
 	ANKI_CHECK(r->getResourceManager().loadResource("shaders/Dbg.frag.glsl", m_frag));
-
-	PipelineInitInfo init;
-	init.m_vertex.m_bindingCount = 1;
-	init.m_vertex.m_bindings[0].m_stride = 2 * sizeof(Vec4);
-	init.m_vertex.m_attributeCount = 2;
-	init.m_vertex.m_attributes[0].m_format = PixelFormat(ComponentFormat::R32G32B32A32, TransformFormat::FLOAT);
-	init.m_vertex.m_attributes[0].m_offset = 0;
-	init.m_vertex.m_attributes[0].m_binding = 0;
-	init.m_vertex.m_attributes[1].m_format = PixelFormat(ComponentFormat::R32G32B32A32, TransformFormat::FLOAT);
-	init.m_vertex.m_attributes[1].m_offset = sizeof(Vec4);
-	init.m_vertex.m_attributes[1].m_binding = 0;
-	init.m_inputAssembler.m_topology = PrimitiveTopology::LINES;
-	init.m_depthStencil.m_depthWriteEnabled = false;
-	init.m_depthStencil.m_format = MS_DEPTH_ATTACHMENT_PIXEL_FORMAT;
-	init.m_color.m_attachmentCount = 1;
-	init.m_color.m_attachments[0].m_format = DBG_COLOR_ATTACHMENT_PIXEL_FORMAT;
-	init.m_shaders[U(ShaderType::VERTEX)] = m_vert->getGrShader();
-	init.m_shaders[U(ShaderType::FRAGMENT)] = m_frag->getGrShader();
-
-	getPpline(true, PrimitiveTopology::LINES) = gr.newInstance<Pipeline>(init);
-
-	init.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLES;
-	getPpline(true, PrimitiveTopology::TRIANGLES) = gr.newInstance<Pipeline>(init);
-
-	init.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
-	getPpline(false, PrimitiveTopology::TRIANGLES) = gr.newInstance<Pipeline>(init);
-
-	init.m_inputAssembler.m_topology = PrimitiveTopology::LINES;
-	getPpline(false, PrimitiveTopology::LINES) = gr.newInstance<Pipeline>(init);
+	m_prog = gr.newInstance<ShaderProgram>(m_vert->getGrShader(), m_frag->getGrShader());
 
 	// Create the vert buffs
 	for(BufferPtr& v : m_vertBuff)
@@ -71,15 +43,6 @@ Error DebugDrawer::init(Renderer* r)
 			sizeof(Vertex) * MAX_VERTS_PER_FRAME, BufferUsageBit::VERTEX, BufferMapAccessBit::WRITE);
 	}
 
-	// Create the resouce groups
-	U c = 0;
-	for(ResourceGroupPtr& rc : m_rcGroup)
-	{
-		ResourceGroupInitInfo rcinit;
-		rcinit.m_vertexBuffers[0].m_buffer = m_vertBuff[c++];
-		rc = gr.newInstance<ResourceGroup>(rcinit);
-	}
-
 	m_mMat.setIdentity();
 	m_vpMat.setIdentity();
 	m_mvpMat.setIdentity();
@@ -95,7 +58,11 @@ void DebugDrawer::prepareFrame(CommandBufferPtr& jobs)
 	void* mapped = m_vertBuff[frame]->map(0, MAX_VERTS_PER_FRAME * sizeof(Vertex), BufferMapAccessBit::WRITE);
 	m_clientVerts = WeakArray<Vertex>(static_cast<Vertex*>(mapped), MAX_VERTS_PER_FRAME);
 
-	m_cmdb->bindResourceGroup(m_rcGroup[frame], 0, nullptr);
+	m_cmdb->bindVertexBuffer(0, m_vertBuff[frame], 0, 2 * sizeof(Vec4));
+	m_cmdb->setVertexAttribute(0, 0, PixelFormat(ComponentFormat::R32G32B32A32, TransformFormat::FLOAT), 0);
+	m_cmdb->setVertexAttribute(1, 0, PixelFormat(ComponentFormat::R32G32B32A32, TransformFormat::FLOAT), sizeof(Vec4));
+
+	m_cmdb->bindShaderProgram(m_prog);
 
 	m_frameVertCount = 0;
 	m_crntDrawVertCount = 0;
@@ -108,7 +75,10 @@ void DebugDrawer::finishFrame()
 
 	flush();
 
-	m_cmdb = CommandBufferPtr(); // Release job chain
+	// Restore state
+	m_cmdb->setDepthCompareFunction(CompareOperation::ALWAYS);
+
+	m_cmdb = CommandBufferPtr(); // Release command buffer
 }
 
 void DebugDrawer::setModelMatrix(const Mat4& m)
@@ -168,9 +138,10 @@ void DebugDrawer::flush()
 			ANKI_ASSERT((m_crntDrawVertCount % 3) == 0);
 		}
 
-		m_cmdb->bindPipeline(getPpline(m_depthTestEnabled, m_primitive));
+		m_cmdb->setDepthCompareFunction((m_depthTestEnabled) ? CompareOperation::LESS : CompareOperation::ALWAYS);
+
 		U firstVert = m_frameVertCount - m_crntDrawVertCount;
-		m_cmdb->drawArrays(m_crntDrawVertCount, 1, firstVert);
+		m_cmdb->drawArrays(m_primitive, m_crntDrawVertCount, 1, firstVert);
 
 		m_crntDrawVertCount = 0;
 	}

src/anki/renderer/DebugDrawer.h

@@ -88,8 +88,7 @@ private:
 	Renderer* m_r;
 	ShaderResourcePtr m_frag;
 	ShaderResourcePtr m_vert;
-	Array2d<PipelinePtr, 2, 2> m_pplines;
-	Array<ResourceGroupPtr, MAX_FRAMES_IN_FLIGHT> m_rcGroup;
+	ShaderProgramPtr m_prog;
 	Array<BufferPtr, MAX_FRAMES_IN_FLIGHT> m_vertBuff;
 
 	CommandBufferPtr m_cmdb;
@@ -107,13 +106,6 @@ private:
 
 	Bool8 m_depthTestEnabled = true;
 
-	PipelinePtr& getPpline(Bool depth, PrimitiveTopology topology)
-	{
-		U i = (depth == false) ? 0 : 1;
-		U j = (topology == PrimitiveTopology::LINES) ? 0 : 1;
-		return m_pplines[i][j];
-	}
-
 	void flush();
 };
 

src/anki/renderer/DepthDownscale.cpp

@@ -66,7 +66,7 @@ void HalfDepth::run(RenderingContext& ctx)
 	cmdb->bindTexture(0, 0, m_r->getMs().m_depthRt);
 
 	cmdb->setViewport(0, 0, m_r->getWidth() / 2, m_r->getHeight() / 2);
-	cmdb->enableDepthWrite(true);
+	cmdb->setDepthWrite(true);
 	cmdb->setDepthCompareFunction(CompareOperation::ALWAYS);
 
 	m_r->drawQuad(cmdb);
@@ -130,7 +130,7 @@ void QuarterDepth::run(RenderingContext& ctx)
 	cmdb->bindTexture(0, 0, m_parent->m_hd.m_depthRt);
 
 	cmdb->setViewport(0, 0, m_r->getWidth() / 4, m_r->getHeight() / 4);
-	cmdb->enableDepthWrite(true);
+	cmdb->setDepthWrite(true);
 	cmdb->setDepthCompareFunction(CompareOperation::ALWAYS);
 
 	m_r->drawQuad(cmdb);

src/anki/renderer/DownscaleBlur.cpp

@@ -19,34 +19,17 @@ Error DownscaleBlur::initSubpass(U idx, const UVec2& inputTexSize)
 {
 	Subpass& pass = m_passes[idx];
 
-	PipelineInitInfo ppinit;
-	ppinit.m_color.m_attachmentCount = 1;
-	ppinit.m_color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-	ppinit.m_depthStencil.m_depthWriteEnabled = false;
-	ppinit.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
-
-	StringAuto pps(getAllocator());
-
-	// vert shader
-	ANKI_CHECK(getResourceManager().loadResource("shaders/Quad.vert.glsl", pass.m_vert));
-
-	ppinit.m_shaders[ShaderType::VERTEX] = pass.m_vert->getGrShader();
-
 	// frag shader
-	pps.destroy();
-	pps.sprintf("#define TEXTURE_SIZE vec2(%f, %f)\n"
-				"#define TEXTURE_MIPMAP float(%u)\n",
+	ANKI_CHECK(m_r->createShaderf("shaders/DownscaleBlur.frag.glsl",
+		pass.m_frag,
+		"#define TEXTURE_SIZE vec2(%f, %f)\n"
+		"#define TEXTURE_MIPMAP float(%u)\n",
 		F32(inputTexSize.x()),
 		F32(inputTexSize.y()),
-		idx);
+		idx));
 
-	ANKI_CHECK(getResourceManager().loadResourceToCache(
-		pass.m_frag, "shaders/DownscaleBlur.frag.glsl", pps.toCString(), "r_"));
-
-	ppinit.m_shaders[ShaderType::FRAGMENT] = pass.m_frag->getGrShader();
-
-	// ppline
-	pass.m_ppline = getGrManager().newInstance<Pipeline>(ppinit);
+	// prog
+	m_r->createDrawQuadShaderProgram(pass.m_frag->getGrShader(), pass.m_prog);
 
 	// FB
 	FramebufferInitInfo fbInit;
@@ -57,15 +40,23 @@ Error DownscaleBlur::initSubpass(U idx, const UVec2& inputTexSize)
 	fbInit.m_colorAttachments[0].m_usageInsideRenderPass = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
 	pass.m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
 
-	// Resources
-	ResourceGroupInitInfo rcinit;
-	rcinit.m_textures[0].m_texture = m_r->getIs().getRt();
-	pass.m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcinit);
-
 	return ErrorCode::NONE;
 }
 
-Error DownscaleBlur::init(const ConfigSet& initializer)
+Error DownscaleBlur::init(const ConfigSet& cfg)
+{
+	ANKI_LOGI("Initializing dowscale blur");
+
+	Error err = initInternal(cfg);
+	if(err)
+	{
+		ANKI_LOGE("Failed to initialize downscale blur");
+	}
+
+	return err;
+}
+
+Error DownscaleBlur::initInternal(const ConfigSet&)
 {
 	m_passes.create(getAllocator(), m_r->getIs().getRtMipmapCount() - 1);
 
@@ -82,6 +73,9 @@ Error DownscaleBlur::init(const ConfigSet& initializer)
 void DownscaleBlur::run(RenderingContext& ctx)
 {
 	CommandBufferPtr cmdb = ctx.m_commandBuffer;
+
+	cmdb->bindTexture(0, 0, m_r->getIs().getRt());
+
 	UVec2 size(m_r->getWidth(), m_r->getHeight());
 	for(U i = 0; i < m_passes.getSize(); ++i)
 	{
@@ -103,8 +97,7 @@ void DownscaleBlur::run(RenderingContext& ctx)
 
 		cmdb->beginRenderPass(pass.m_fb);
 		cmdb->setViewport(0, 0, size.x(), size.y());
-		cmdb->bindPipeline(pass.m_ppline);
-		cmdb->bindResourceGroup(pass.m_rcGroup, 0, nullptr);
+		cmdb->bindShaderProgram(pass.m_prog);
 
 		m_r->drawQuad(cmdb);
 		cmdb->endRenderPass();

src/anki/renderer/DownscaleBlur.h

@@ -24,7 +24,7 @@ anki_internal:
 
 	~DownscaleBlur();
 
-	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
+	ANKI_USE_RESULT Error init(const ConfigSet& cfg);
 
 	void run(RenderingContext& ctx);
 
@@ -32,16 +32,15 @@ private:
 	class Subpass
 	{
 	public:
-		ShaderResourcePtr m_vert;
 		ShaderResourcePtr m_frag;
-		PipelinePtr m_ppline;
-		ResourceGroupPtr m_rcGroup;
+		ShaderProgramPtr m_prog;
 		FramebufferPtr m_fb;
 	};
 
 	DynamicArray<Subpass> m_passes;
 
-	Error initSubpass(U idx, const UVec2& inputTexSize);
+	ANKI_USE_RESULT Error initInternal(const ConfigSet& cfg);
+	ANKI_USE_RESULT Error initSubpass(U idx, const UVec2& inputTexSize);
 };
 /// @}
 

src/anki/renderer/Fs.cpp

@@ -18,10 +18,6 @@ namespace anki
 
 Fs::~Fs()
 {
-	if(m_pplineCache)
-	{
-		getAllocator().deleteInstance(m_pplineCache);
-	}
 }
 
 Error Fs::init(const ConfigSet&)
@@ -50,43 +46,6 @@ Error Fs::init(const ConfigSet&)
 	fbInit.m_depthStencilAttachment.m_aspect = DepthStencilAspectMask::DEPTH;
 	m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
 
-	// Init the global resources
-	{
-		ResourceGroupInitInfo init;
-		init.m_textures[0].m_texture = m_r->getDepthDownscale().m_hd.m_depthRt;
-		init.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
-		init.m_textures[1].m_texture = m_r->getSm().getSpotTextureArray();
-		init.m_textures[2].m_texture = m_r->getSm().getOmniTextureArray();
-
-		init.m_uniformBuffers[0].m_uploadedMemory = true;
-		init.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-		init.m_uniformBuffers[1].m_uploadedMemory = true;
-		init.m_uniformBuffers[1].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-		init.m_uniformBuffers[2].m_uploadedMemory = true;
-		init.m_uniformBuffers[2].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-
-		init.m_storageBuffers[0].m_uploadedMemory = true;
-		init.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ | BufferUsageBit::STORAGE_VERTEX_READ;
-		init.m_storageBuffers[1].m_uploadedMemory = true;
-		init.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ | BufferUsageBit::STORAGE_VERTEX_READ;
-
-		m_globalResources = getGrManager().newInstance<ResourceGroup>(init);
-	}
-
-	// Init state
-	{
-		ColorStateInfo& color = m_state.m_color;
-		color.m_attachmentCount = 1;
-		color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-		color.m_attachments[0].m_srcBlendMethod = BlendMethod::SRC_ALPHA;
-		color.m_attachments[0].m_dstBlendMethod = BlendMethod::ONE_MINUS_SRC_ALPHA;
-
-		m_state.m_depthStencil.m_format = MS_DEPTH_ATTACHMENT_PIXEL_FORMAT;
-		m_state.m_depthStencil.m_depthWriteEnabled = false;
-	}
-
-	m_pplineCache = getAllocator().newInstance<GrObjectCache>(&getGrManager());
-
 	ANKI_CHECK(initVol());
 
 	return ErrorCode::NONE;
@@ -94,32 +53,18 @@ Error Fs::init(const ConfigSet&)
 
 Error Fs::initVol()
 {
-	ANKI_CHECK(m_r->createShader("shaders/VolumetricUpscale.frag.glsl",
+	ANKI_CHECK(m_r->createShaderf("shaders/VolumetricUpscale.frag.glsl",
 		m_vol.m_frag,
 		"#define SRC_SIZE vec2(float(%u), float(%u))\n",
 		m_r->getWidth() / VOLUMETRIC_FRACTION,
 		m_r->getHeight() / VOLUMETRIC_FRACTION));
 
-	ColorStateInfo color;
-	color.m_attachmentCount = 1;
-	color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-	color.m_attachments[0].m_srcBlendMethod = BlendMethod::ONE;
-	color.m_attachments[0].m_dstBlendMethod = BlendMethod::ONE;
-	m_r->createDrawQuadPipeline(m_vol.m_frag->getGrShader(), color, m_vol.m_ppline);
+	m_r->createDrawQuadShaderProgram(m_vol.m_frag->getGrShader(), m_vol.m_prog);
 
 	SamplerInitInfo sinit;
 	sinit.m_repeat = false;
 	sinit.m_mipmapFilter = SamplingFilter::NEAREST;
-
-	ResourceGroupInitInfo rcinit;
-	rcinit.m_textures[0].m_texture = m_r->getDepthDownscale().m_hd.m_depthRt;
-	rcinit.m_textures[0].m_sampler = getGrManager().newInstance<Sampler>(sinit);
-	rcinit.m_textures[1].m_texture = m_r->getDepthDownscale().m_qd.m_depthRt;
-	rcinit.m_textures[1].m_sampler = rcinit.m_textures[0].m_sampler;
-	rcinit.m_textures[2].m_texture = m_r->getVolumetric().m_rt;
-	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
-	rcinit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
-	m_vol.m_rc = getGrManager().newInstance<ResourceGroup>(rcinit);
+	m_vol.m_nearestSampler = getGrManager().newInstance<Sampler>(sinit);
 
 	return ErrorCode::NONE;
 }
@@ -128,16 +73,26 @@ void Fs::drawVolumetric(RenderingContext& ctx, CommandBufferPtr cmdb)
 {
 	const Frustum& fr = ctx.m_frustumComponent->getFrustum();
 
-	cmdb->bindPipeline(m_vol.m_ppline);
+	cmdb->bindShaderProgram(m_vol.m_prog);
+	cmdb->setBlendMethods(0, BlendMethod::ONE, BlendMethod::ONE);
 
-	TransientMemoryInfo trans;
-	Vec4* unis = static_cast<Vec4*>(getGrManager().allocateFrameTransientMemory(
-		sizeof(Vec4), BufferUsageBit::UNIFORM_ALL, trans.m_uniformBuffers[0]));
+	cmdb->bindShaderProgram(m_vol.m_prog);
+
+	TransientMemoryToken token;
+	Vec4* unis = static_cast<Vec4*>(
+		getGrManager().allocateFrameTransientMemory(sizeof(Vec4), BufferUsageBit::UNIFORM_ALL, token));
 	computeLinearizeDepthOptimal(fr.getNear(), fr.getFar(), unis->x(), unis->y());
 
-	cmdb->bindResourceGroup(m_vol.m_rc, 0, &trans);
+	cmdb->bindTextureAndSampler(0, 0, m_r->getDepthDownscale().m_hd.m_depthRt, m_vol.m_nearestSampler);
+	cmdb->bindTextureAndSampler(0, 1, m_r->getDepthDownscale().m_qd.m_depthRt, m_vol.m_nearestSampler);
+	cmdb->bindTexture(0, 2, m_r->getVolumetric().m_rt);
+
+	cmdb->bindUniformBuffer(0, 0, token);
 
 	m_r->drawQuad(cmdb);
+
+	// Restore state
+	cmdb->setBlendMethods(0, BlendMethod::ONE, BlendMethod::ZERO);
 }
 
 Error Fs::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
@@ -157,21 +112,29 @@ Error Fs::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount)
 
 	// Create the command buffer and set some state
 	CommandBufferInitInfo cinf;
-	cinf.m_flags = CommandBufferFlag::SECOND_LEVEL;
+	cinf.m_flags = CommandBufferFlag::SECOND_LEVEL | CommandBufferFlag::GRAPHICS_WORK;
 	cinf.m_framebuffer = m_fb;
 	CommandBufferPtr cmdb = m_r->getGrManager().newInstance<CommandBuffer>(cinf);
 	ctx.m_fs.m_commandBuffers[threadId] = cmdb;
 
 	cmdb->setViewport(0, 0, m_width, m_height);
-	cmdb->setPolygonOffset(0.0, 0.0);
-	cmdb->bindResourceGroup(m_globalResources, 1, &ctx.m_is.m_dynBufferInfo);
+
+	cmdb->bindTexture(1, 0, m_r->getDepthDownscale().m_hd.m_depthRt);
+	cmdb->bindTexture(1, 1, m_r->getSm().m_spotTexArray);
+	cmdb->bindTexture(1, 2, m_r->getSm().m_omniTexArray);
+	cmdb->bindUniformBuffer(1, 0, ctx.m_is.m_commonToken);
+	cmdb->bindUniformBuffer(1, 1, ctx.m_is.m_pointLightsToken);
+	cmdb->bindUniformBuffer(1, 2, ctx.m_is.m_spotLightsToken);
+	cmdb->bindStorageBuffer(1, 0, ctx.m_is.m_clustersToken);
+	cmdb->bindStorageBuffer(1, 1, ctx.m_is.m_lightIndicesToken);
+
+	cmdb->setBlendMethods(0, BlendMethod::SRC_ALPHA, BlendMethod::ONE_MINUS_SRC_ALPHA);
+	cmdb->setDepthWrite(false);
 
 	// Start drawing
 	Error err = m_r->getSceneDrawer().drawRange(Pass::MS_FS,
 		*ctx.m_frustumComponent,
 		cmdb,
-		*m_pplineCache,
-		m_state,
 		vis.getBegin(VisibilityGroupType::RENDERABLES_FS) + start,
 		vis.getBegin(VisibilityGroupType::RENDERABLES_FS) + end);
 

src/anki/renderer/Fs.h

@@ -61,16 +61,13 @@ private:
 	U m_height;
 	FramebufferPtr m_fb;
 	TexturePtr m_rt;
-	ResourceGroupPtr m_globalResources;
-	PipelineInitInfo m_state;
-	GrObjectCache* m_pplineCache = nullptr;
 
 	class Vol
 	{
 	public:
 		ShaderResourcePtr m_frag;
-		PipelinePtr m_ppline;
-		ResourceGroupPtr m_rc;
+		ShaderProgramPtr m_prog;
+		SamplerPtr m_nearestSampler;
 	} m_vol;
 
 	ANKI_USE_RESULT Error initVol();

src/anki/renderer/FsUpscale.cpp

@@ -18,29 +18,25 @@ namespace anki
 
 Error FsUpscale::init(const ConfigSet& config)
 {
+	Error err = initInternal(config);
+	if(err)
+	{
+		ANKI_LOGE("Failed to initialize forward shading upscale");
+	}
+
+	return err;
+}
+
+Error FsUpscale::initInternal(const ConfigSet& config)
+{
+	ANKI_LOGE("Initializing forward shading upscale");
+
 	GrManager& gr = getGrManager();
 
-	// Create RC group
-	ResourceGroupInitInfo rcInit;
 	SamplerInitInfo sinit;
 	sinit.m_repeat = false;
-
-	rcInit.m_textures[0].m_texture = m_r->getMs().m_depthRt;
-	rcInit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
-
 	sinit.m_mipmapFilter = SamplingFilter::NEAREST;
-	rcInit.m_textures[1].m_texture = m_r->getDepthDownscale().m_hd.m_depthRt;
-	rcInit.m_textures[1].m_sampler = gr.newInstance<Sampler>(sinit);
-	rcInit.m_textures[1].m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
-
-	rcInit.m_textures[2].m_texture = m_r->getFs().getRt();
-
-	rcInit.m_textures[3].m_texture = m_r->getSsao().getRt();
-
-	rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
-	rcInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
-
-	m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
+	m_nearestSampler = gr.newInstance<Sampler>(sinit);
 
 	// Shader
 	StringAuto pps(getFrameAllocator());
@@ -50,24 +46,12 @@ Error FsUpscale::init(const ConfigSet& config)
 		m_r->getHeight() / FS_FRACTION,
 		1);
 
-	ANKI_CHECK(getResourceManager().loadResourceToCache(m_frag, "shaders/FsUpscale.frag.glsl", pps.toCString(), "r_"));
-
-	ANKI_CHECK(getResourceManager().loadResourceToCache(m_vert, "shaders/Quad.vert.glsl", pps.toCString(), "r_"));
-
-	// Ppline
-	PipelineInitInfo ppinit;
-
-	ppinit.m_depthStencil.m_depthWriteEnabled = false;
-	ppinit.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
+	ANKI_CHECK(m_r->createShader("shaders/FsUpscale.frag.glsl", m_frag, pps.toCString()));
 
-	ppinit.m_color.m_attachmentCount = 1;
-	ppinit.m_color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-	ppinit.m_color.m_attachments[0].m_srcBlendMethod = BlendMethod::ONE;
-	ppinit.m_color.m_attachments[0].m_dstBlendMethod = BlendMethod::SRC_ALPHA;
+	ANKI_CHECK(m_r->createShader("shaders/Quad.vert.glsl", m_vert, pps.toCString()));
 
-	ppinit.m_shaders[U(ShaderType::VERTEX)] = m_vert->getGrShader();
-	ppinit.m_shaders[U(ShaderType::FRAGMENT)] = m_frag->getGrShader();
-	m_ppline = gr.newInstance<Pipeline>(ppinit);
+	// Prog
+	m_prog = gr.newInstance<ShaderProgram>(m_vert->getGrShader(), m_frag->getGrShader());
 
 	// Create FB
 	FramebufferInitInfo fbInit;
@@ -83,20 +67,31 @@ Error FsUpscale::init(const ConfigSet& config)
 void FsUpscale::run(RenderingContext& ctx)
 {
 	CommandBufferPtr cmdb = ctx.m_commandBuffer;
-	TransientMemoryInfo dyn;
 
-	Vec4* linearDepth = static_cast<Vec4*>(getGrManager().allocateFrameTransientMemory(
-		sizeof(Vec4), BufferUsageBit::UNIFORM_ALL, dyn.m_uniformBuffers[0]));
+	TransientMemoryToken token;
+
+	Vec4* linearDepth = static_cast<Vec4*>(
+		getGrManager().allocateFrameTransientMemory(sizeof(Vec4), BufferUsageBit::UNIFORM_ALL, token));
 	const Frustum& fr = ctx.m_frustumComponent->getFrustum();
 	computeLinearizeDepthOptimal(fr.getNear(), fr.getFar(), linearDepth->x(), linearDepth->y());
 
+	cmdb->bindUniformBuffer(0, 0, token);
+	cmdb->bindTexture(0, 0, m_r->getMs().m_depthRt);
+	cmdb->bindTextureAndSampler(0, 1, m_r->getMs().m_depthRt, m_nearestSampler);
+	cmdb->bindTexture(0, 2, m_r->getFs().getRt());
+	cmdb->bindTexture(0, 3, m_r->getSsao().getRt());
+
+	cmdb->setBlendMethods(0, BlendMethod::ONE, BlendMethod::SRC_ALPHA);
+
 	cmdb->beginRenderPass(m_fb);
-	cmdb->bindPipeline(m_ppline);
+	cmdb->bindShaderProgram(m_prog);
 	cmdb->setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
-	cmdb->bindResourceGroup(m_rcGroup, 0, &dyn);
 
 	m_r->drawQuad(cmdb);
 	cmdb->endRenderPass();
+
+	// Restore state
+	cmdb->setBlendMethods(0, BlendMethod::ONE, BlendMethod::ZERO);
 }
 
 } // end namespace anki

src/anki/renderer/FsUpscale.h

@@ -27,11 +27,13 @@ public:
 	void run(RenderingContext& ctx);
 
 private:
-	ResourceGroupPtr m_rcGroup;
 	FramebufferPtr m_fb;
 	ShaderResourcePtr m_frag;
 	ShaderResourcePtr m_vert;
-	PipelinePtr m_ppline;
+	ShaderProgramPtr m_prog;
+	SamplerPtr m_nearestSampler;
+
+	ANKI_USE_RESULT Error initInternal(const ConfigSet& config);
 };
 /// @}
 

src/anki/renderer/Ir.cpp

@@ -205,29 +205,6 @@ void Ir::initFaceInfo(U cacheEntryIdx, U faceIdx)
 
 	face.m_isFb = getGrManager().newInstance<Framebuffer>(fbInit);
 
-	// Create the IS resource group
-	ResourceGroupInitInfo rcinit;
-	rcinit.m_textures[0].m_texture = face.m_gbufferColorRts[0];
-	rcinit.m_textures[1].m_texture = face.m_gbufferColorRts[1];
-	rcinit.m_textures[2].m_texture = face.m_gbufferColorRts[2];
-	rcinit.m_textures[3].m_texture = face.m_gbufferDepthRt;
-	rcinit.m_textures[3].m_usage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ | TextureUsageBit::SAMPLED_FRAGMENT;
-
-	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
-	rcinit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-	rcinit.m_uniformBuffers[1].m_uploadedMemory = true;
-	rcinit.m_uniformBuffers[1].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-
-	rcinit.m_vertexBuffers[0].m_buffer = m_is.m_plightPositions;
-	rcinit.m_indexBuffer.m_buffer = m_is.m_plightIndices;
-	rcinit.m_indexSize = 2;
-
-	face.m_plightRsrc = getGrManager().newInstance<ResourceGroup>(rcinit);
-
-	rcinit.m_vertexBuffers[0].m_buffer = m_is.m_slightPositions;
-	rcinit.m_indexBuffer.m_buffer = m_is.m_slightIndices;
-	face.m_slightRsrc = getGrManager().newInstance<ResourceGroup>(rcinit);
-
 	// Create irradiance FB
 	fbInit = FramebufferInitInfo();
 	fbInit.m_colorAttachmentCount = 1;
@@ -287,52 +264,28 @@ Error Ir::initIs()
 	// Init shaders
 	ANKI_CHECK(getResourceManager().loadResource("shaders/Light.vert.glsl", m_is.m_lightVert));
 
-	StringAuto pps(getAllocator());
-	pps.sprintf("#define POINT_LIGHT\n"
-				"#define RENDERING_WIDTH %d\n"
-				"#define RENDERING_HEIGHT %d\n",
+	ANKI_CHECK(m_r->createShaderf("shaders/Light.frag.glsl",
+		m_is.m_plightFrag,
+		"#define POINT_LIGHT\n"
+		"#define RENDERING_WIDTH %d\n"
+		"#define RENDERING_HEIGHT %d\n",
 		m_fbSize,
-		m_fbSize);
-
-	ANKI_CHECK(
-		getResourceManager().loadResourceToCache(m_is.m_plightFrag, "shaders/Light.frag.glsl", pps.toCString(), "r_"));
+		m_fbSize));
 
-	pps.destroy();
-	pps.sprintf("#define SPOT_LIGHT\n"
-				"#define RENDERING_WIDTH %d\n"
-				"#define RENDERING_HEIGHT %d\n",
+	ANKI_CHECK(m_r->createShaderf("shaders/Light.frag.glsl",
+		m_is.m_slightFrag,
+		"#define SPOT_LIGHT\n"
+		"#define RENDERING_WIDTH %d\n"
+		"#define RENDERING_HEIGHT %d\n",
 		m_fbSize,
-		m_fbSize);
-
-	ANKI_CHECK(
-		getResourceManager().loadResourceToCache(m_is.m_slightFrag, "shaders/Light.frag.glsl", pps.toCString(), "r_"));
-
-	// Init the pplines
-	PipelineInitInfo pinit;
-	pinit.m_vertex.m_attributeCount = 1;
-	pinit.m_vertex.m_attributes[0].m_format = PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT);
-	pinit.m_vertex.m_bindingCount = 1;
-	pinit.m_vertex.m_bindings[0].m_stride = sizeof(F32) * 3;
-
-	pinit.m_rasterizer.m_cullMode = FaceSelectionMask::FRONT;
-
-	pinit.m_depthStencil.m_depthWriteEnabled = false;
-	pinit.m_depthStencil.m_depthCompareFunction = CompareOperation::GREATER;
-	pinit.m_depthStencil.m_format = MS_DEPTH_ATTACHMENT_PIXEL_FORMAT;
+		m_fbSize));
 
-	pinit.m_color.m_attachmentCount = 1;
-	auto& att = pinit.m_color.m_attachments[0];
-	att.m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-	att.m_srcBlendMethod = BlendMethod::ONE;
-	att.m_dstBlendMethod = BlendMethod::ONE;
+	// Init the progs
+	m_is.m_plightProg =
+		getGrManager().newInstance<ShaderProgram>(m_is.m_lightVert->getGrShader(), m_is.m_plightFrag->getGrShader());
 
-	pinit.m_shaders[ShaderType::VERTEX] = m_is.m_lightVert->getGrShader();
-	pinit.m_shaders[ShaderType::FRAGMENT] = m_is.m_plightFrag->getGrShader();
-
-	m_is.m_plightPpline = getGrManager().newInstance<Pipeline>(pinit);
-
-	pinit.m_shaders[ShaderType::FRAGMENT] = m_is.m_slightFrag->getGrShader();
-	m_is.m_slightPpline = getGrManager().newInstance<Pipeline>(pinit);
+	m_is.m_slightProg =
+		getGrManager().newInstance<ShaderProgram>(m_is.m_lightVert->getGrShader(), m_is.m_slightFrag->getGrShader());
 
 	// Init vert/idx buffers
 	ANKI_CHECK(
@@ -366,26 +319,11 @@ Error Ir::initIrradiance()
 	m_irradiance.m_cubeArr = getGrManager().newInstance<Texture>(texinit);
 
 	// Create the shader
-	StringAuto pps(getFrameAllocator());
-	pps.sprintf("#define CUBEMAP_SIZE %u\n", IRRADIANCE_TEX_SIZE);
-
-	ANKI_CHECK(getResourceManager().loadResourceToCache(
-		m_irradiance.m_frag, "shaders/Irradiance.frag.glsl", pps.toCString(), "r_"));
-
-	// Create the ppline
-	ColorStateInfo colorInf;
-	colorInf.m_attachmentCount = 1;
-	colorInf.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-
-	m_r->createDrawQuadPipeline(m_irradiance.m_frag->getGrShader(), colorInf, m_irradiance.m_ppline);
-
-	// Create the resources
-	ResourceGroupInitInfo rcInit;
-	rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
-	rcInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-	rcInit.m_textures[0].m_texture = m_is.m_lightRt;
+	ANKI_CHECK(m_r->createShaderf(
+		"shaders/Irradiance.frag.glsl", m_irradiance.m_frag, "#define CUBEMAP_SIZE %u\n", IRRADIANCE_TEX_SIZE));
 
-	m_irradiance.m_rsrc = getGrManager().newInstance<ResourceGroup>(rcInit);
+	// Create the prog
+	m_r->createDrawQuadShaderProgram(m_irradiance.m_frag->getGrShader(), m_irradiance.m_prog);
 
 	// Clear texture
 	CommandBufferInitInfo cinf;
@@ -443,14 +381,11 @@ Error Ir::runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceId
 	// Start render pass
 	cmdb->beginRenderPass(face.m_msFb);
 	cmdb->setViewport(0, 0, m_fbSize, m_fbSize);
-	cmdb->setPolygonOffset(0.0, 0.0);
 
 	/// Draw
 	ANKI_CHECK(m_r->getSceneDrawer().drawRange(Pass::MS_FS,
 		frc,
 		cmdb,
-		*m_r->getMs().m_pplineCache,
-		m_r->getMs().m_state,
 		vis.getBegin(VisibilityGroupType::RENDERABLES_MS),
 		vis.getEnd(VisibilityGroupType::RENDERABLES_MS)));
 
@@ -487,11 +422,23 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 
 	cmdb->beginRenderPass(face.m_isFb);
 
+	cmdb->bindTexture(0, 0, face.m_gbufferColorRts[0]);
+	cmdb->bindTexture(0, 1, face.m_gbufferColorRts[1]);
+	cmdb->bindTexture(0, 2, face.m_gbufferColorRts[2]);
+
+	cmdb->setVertexAttribute(0, 0, PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT), 0);
+
+	cmdb->setBlendMethods(0, BlendMethod::ONE, BlendMethod::ONE);
+	cmdb->setDepthWrite(false);
+	cmdb->setDepthCompareFunction(CompareOperation::GREATER);
+
 	// Process all lights
 	const Mat4& vpMat = frc.getViewProjectionMatrix();
 	const Mat4& vMat = frc.getViewMatrix();
 
-	cmdb->bindPipeline(m_is.m_plightPpline);
+	cmdb->bindShaderProgram(m_is.m_plightProg);
+	cmdb->bindVertexBuffer(0, m_is.m_plightPositions, 0, sizeof(F32) * 3);
+	cmdb->bindIndexBuffer(m_is.m_plightIndices, 0, IndexType::U16);
 
 	const VisibleNode* it = vis.getBegin(VisibilityGroupType::LIGHTS_POINT);
 	const VisibleNode* end = vis.getEnd(VisibilityGroupType::LIGHTS_POINT);
@@ -500,11 +447,11 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 		const LightComponent& lightc = it->m_node->getComponent<LightComponent>();
 		const MoveComponent& movec = it->m_node->getComponent<MoveComponent>();
 
-		TransientMemoryInfo transient;
+		TransientMemoryToken uniVertToken, uniFragToken;
 
 		// Update uniforms
-		IrVertex* vert = static_cast<IrVertex*>(getGrManager().allocateFrameTransientMemory(
-			sizeof(IrVertex), BufferUsageBit::UNIFORM_ALL, transient.m_uniformBuffers[0]));
+		IrVertex* vert = static_cast<IrVertex*>(
+			getGrManager().allocateFrameTransientMemory(sizeof(IrVertex), BufferUsageBit::UNIFORM_ALL, uniVertToken));
 
 		Mat4 modelM(movec.getWorldTransform().getOrigin().xyz1(),
 			movec.getWorldTransform().getRotation().getRotationPart(),
@@ -513,7 +460,7 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 		vert->m_mvp = vpMat * modelM;
 
 		IrPointLight* light = static_cast<IrPointLight*>(getGrManager().allocateFrameTransientMemory(
-			sizeof(IrPointLight), BufferUsageBit::UNIFORM_ALL, transient.m_uniformBuffers[1]));
+			sizeof(IrPointLight), BufferUsageBit::UNIFORM_ALL, uniFragToken));
 
 		Vec4 pos = vMat * movec.getWorldTransform().getOrigin().xyz1();
 
@@ -523,15 +470,18 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 		light->m_specularColorPad1 = lightc.getSpecularColor();
 
 		// Bind stuff
-		cmdb->bindResourceGroup(face.m_plightRsrc, 0, &transient);
+		cmdb->bindUniformBuffer(0, 0, uniVertToken);
+		cmdb->bindUniformBuffer(0, 1, uniFragToken);
 
 		// Draw
-		cmdb->drawElements(m_is.m_plightIdxCount);
+		cmdb->drawElements(PrimitiveTopology::TRIANGLES, m_is.m_plightIdxCount);
 
 		++it;
 	}
 
-	cmdb->bindPipeline(m_is.m_slightPpline);
+	cmdb->bindShaderProgram(m_is.m_slightProg);
+	cmdb->bindVertexBuffer(0, m_is.m_slightPositions, 0, 0);
+	cmdb->bindIndexBuffer(m_is.m_slightIndices, 0, IndexType::U16);
 
 	it = vis.getBegin(VisibilityGroupType::LIGHTS_SPOT);
 	end = vis.getEnd(VisibilityGroupType::LIGHTS_SPOT);
@@ -554,17 +504,17 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 
 		modelM = modelM * scaleM;
 
-		TransientMemoryInfo transient;
+		TransientMemoryToken uniVertToken, uniFragToken;
 
 		// Update vertex uniforms
-		IrVertex* vert = static_cast<IrVertex*>(getGrManager().allocateFrameTransientMemory(
-			sizeof(IrVertex), BufferUsageBit::UNIFORM_ALL, transient.m_uniformBuffers[0]));
+		IrVertex* vert = static_cast<IrVertex*>(
+			getGrManager().allocateFrameTransientMemory(sizeof(IrVertex), BufferUsageBit::UNIFORM_ALL, uniVertToken));
 
 		vert->m_mvp = vpMat * modelM;
 
 		// Update fragment uniforms
 		IrSpotLight* light = static_cast<IrSpotLight*>(getGrManager().allocateFrameTransientMemory(
-			sizeof(IrSpotLight), BufferUsageBit::UNIFORM_ALL, transient.m_uniformBuffers[1]));
+			sizeof(IrSpotLight), BufferUsageBit::UNIFORM_ALL, uniFragToken));
 
 		light->m_projectionParams = frc.getProjectionParameters();
 
@@ -580,10 +530,11 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 		light->m_lightDirPad1 = lightDir.xyz0();
 
 		// Bind stuff
-		cmdb->bindResourceGroup(face.m_slightRsrc, 0, &transient);
+		cmdb->bindUniformBuffer(0, 0, uniVertToken);
+		cmdb->bindUniformBuffer(0, 1, uniFragToken);
 
 		// Draw
-		cmdb->drawElements(m_is.m_slightIdxCount);
+		cmdb->drawElements(PrimitiveTopology::TRIANGLES, m_is.m_slightIdxCount);
 
 		++it;
 	}
@@ -602,6 +553,11 @@ void Ir::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx
 		TextureUsageBit::GENERATE_MIPMAPS,
 		TextureUsageBit::SAMPLED_FRAGMENT,
 		TextureSurfaceInfo(0, 0, faceIdx, layer));
+
+	// Restore state
+	cmdb->setBlendMethods(0, BlendMethod::ONE, BlendMethod::ZERO);
+	cmdb->setDepthWrite(true);
+	cmdb->setDepthCompareFunction(CompareOperation::LESS);
 }
 
 void Ir::computeIrradiance(RenderingContext& rctx, U layer, U faceIdx)
@@ -618,14 +574,15 @@ void Ir::computeIrradiance(RenderingContext& rctx, U layer, U faceIdx)
 	// Set state and draw
 	cmdb->setViewport(0, 0, IRRADIANCE_TEX_SIZE, IRRADIANCE_TEX_SIZE);
 
-	TransientMemoryInfo dinf;
-	UVec4* faceIdxArrayIdx = static_cast<UVec4*>(getGrManager().allocateFrameTransientMemory(
-		sizeof(UVec4), BufferUsageBit::UNIFORM_ALL, dinf.m_uniformBuffers[0]));
+	TransientMemoryToken token;
+	UVec4* faceIdxArrayIdx = static_cast<UVec4*>(
+		getGrManager().allocateFrameTransientMemory(sizeof(UVec4), BufferUsageBit::UNIFORM_ALL, token));
 	faceIdxArrayIdx->x() = faceIdx;
 	faceIdxArrayIdx->y() = layer;
 
-	cmdb->bindResourceGroup(m_irradiance.m_rsrc, 0, &dinf);
-	cmdb->bindPipeline(m_irradiance.m_ppline);
+	cmdb->bindUniformBuffer(0, 0, token);
+	cmdb->bindTexture(0, 0, m_is.m_lightRt);
+	cmdb->bindShaderProgram(m_irradiance.m_prog);
 	cmdb->beginRenderPass(face.m_irradianceFb);
 
 	m_r->drawQuad(cmdb);

src/anki/renderer/Ir.h

@@ -72,8 +72,6 @@ private:
 
 		// IS
 		FramebufferPtr m_isFb;
-		ResourceGroupPtr m_plightRsrc;
-		ResourceGroupPtr m_slightRsrc;
 
 		// Irradiance
 		FramebufferPtr m_irradianceFb;
@@ -110,8 +108,8 @@ private:
 		ShaderResourcePtr m_lightVert;
 		ShaderResourcePtr m_plightFrag;
 		ShaderResourcePtr m_slightFrag;
-		PipelinePtr m_plightPpline;
-		PipelinePtr m_slightPpline;
+		ShaderProgramPtr m_plightProg;
+		ShaderProgramPtr m_slightProg;
 
 		BufferPtr m_plightPositions;
 		BufferPtr m_plightIndices;
@@ -129,8 +127,7 @@ private:
 		U32 m_cubeArrMipCount = 0;
 
 		ShaderResourcePtr m_frag;
-		PipelinePtr m_ppline;
-		ResourceGroupPtr m_rsrc;
+		ShaderProgramPtr m_prog;
 	} m_irradiance;
 
 	DynamicArray<CacheEntry> m_cacheEntries;

src/anki/renderer/Is.cpp

@@ -108,7 +108,7 @@ Error Is::initInternal(const ConfigSet& config)
 		m_r->getWidth(),
 		m_r->getHeight(),
 		m_maxLightIds,
-		m_r->getSm().getPoissonEnabled(),
+		m_r->getSm().m_poissonEnabled,
 		1,
 		m_r->getIr().getReflectionTextureMipmapCount());
 
@@ -176,8 +176,8 @@ void Is::run(RenderingContext& ctx)
 	cmdb->bindTexture(0, 1, m_r->getMs().m_rt1);
 	cmdb->bindTexture(0, 2, m_r->getMs().m_rt2);
 	cmdb->bindTexture(0, 3, m_r->getMs().m_depthRt, DepthStencilAspectMask::DEPTH);
-	cmdb->bindTexture(0, 4, m_r->getSm().getSpotTextureArray());
-	cmdb->bindTexture(0, 5, m_r->getSm().getOmniTextureArray());
+	cmdb->bindTexture(0, 4, m_r->getSm().m_spotTexArray);
+	cmdb->bindTexture(0, 5, m_r->getSm().m_omniTexArray);
 	cmdb->bindTexture(0, 6, m_r->getIr().getReflectionTexture());
 	cmdb->bindTexture(0, 7, m_r->getIr().getIrradianceTexture());
 	cmdb->bindTextureAndSampler(0, 8, m_r->getIr().getIntegrationLut(), m_r->getIr().getIntegrationLutSampler());
@@ -236,7 +236,7 @@ Error Is::getOrCreateProgram(ShaderVariantBit variantMask, RenderingContext& ctx
 	{
 		ShaderVariant variant;
 
-		ANKI_CHECK(m_r->createShader("shaders/Is.frag.glsl",
+		ANKI_CHECK(m_r->createShaderf("shaders/Is.frag.glsl",
 			variant.m_lightFrag,
 			"#define TILE_COUNT_X %u\n"
 			"#define TILE_COUNT_Y %u\n"
@@ -258,7 +258,7 @@ Error Is::getOrCreateProgram(ShaderVariantBit variantMask, RenderingContext& ctx
 			m_r->getWidth(),
 			m_r->getHeight(),
 			m_maxLightIds,
-			m_r->getSm().getPoissonEnabled(),
+			m_r->getSm().m_poissonEnabled,
 			!!(variantMask & ShaderVariantBit::INDIRECT),
 			m_r->getIr().getReflectionTextureMipmapCount(),
 			!!(variantMask & ShaderVariantBit::P_LIGHTS),

src/anki/renderer/Lf.cpp

@@ -34,10 +34,12 @@ Lf::~Lf()
 
 Error Lf::init(const ConfigSet& config)
 {
+	ANKI_LOGE("Initializing lens flare pass");
+
 	Error err = initInternal(config);
 	if(err)
 	{
-		ANKI_LOGE("Failed to init lens flare pass");
+		ANKI_LOGE("Failed to initialize lens flare pass");
 	}
 
 	return err;
@@ -48,7 +50,6 @@ Error Lf::initInternal(const ConfigSet& config)
 	ANKI_CHECK(initSprite(config));
 	ANKI_CHECK(initOcclusion(config));
 
-	getGrManager().finish();
 	return ErrorCode::NONE;
 }
 
@@ -70,26 +71,12 @@ Error Lf::initSprite(const ConfigSet& config)
 
 	pps.sprintf("#define MAX_SPRITES %u\n", m_maxSprites);
 
-	ANKI_CHECK(
-		getResourceManager().loadResourceToCache(m_realVert, "shaders/LfSpritePass.vert.glsl", pps.toCString(), "r_"));
-
-	ANKI_CHECK(
-		getResourceManager().loadResourceToCache(m_realFrag, "shaders/LfSpritePass.frag.glsl", pps.toCString(), "r_"));
-
-	// Create ppline.
-	// Writes to IS with blending
-	PipelineInitInfo init;
-	init.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
-	init.m_depthStencil.m_depthWriteEnabled = false;
-	init.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
-	init.m_depthStencil.m_format = MS_DEPTH_ATTACHMENT_PIXEL_FORMAT;
-	init.m_color.m_attachmentCount = 1;
-	init.m_color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
-	init.m_color.m_attachments[0].m_srcBlendMethod = BlendMethod::ONE;
-	init.m_color.m_attachments[0].m_dstBlendMethod = BlendMethod::ONE;
-	init.m_shaders[U(ShaderType::VERTEX)] = m_realVert->getGrShader();
-	init.m_shaders[U(ShaderType::FRAGMENT)] = m_realFrag->getGrShader();
-	m_realPpline = getGrManager().newInstance<Pipeline>(init);
+	ANKI_CHECK(m_r->createShader("shaders/LfSpritePass.vert.glsl", m_realVert, pps.toCString()));
+
+	ANKI_CHECK(m_r->createShader("shaders/LfSpritePass.frag.glsl", m_realFrag, pps.toCString()));
+
+	// Create prog.
+	m_realProg = getGrManager().newInstance<ShaderProgram>(m_realVert->getGrShader(), m_realFrag->getGrShader());
 
 	return ErrorCode::NONE;
 }
@@ -112,48 +99,9 @@ Error Lf::initOcclusion(const ConfigSet& config)
 	ANKI_CHECK(getResourceManager().loadResource("shaders/LfOcclusion.frag.glsl", m_occlusionFrag));
 	ANKI_CHECK(getResourceManager().loadResource("shaders/LfUpdateIndirectInfo.comp.glsl", m_writeIndirectBuffComp));
 
-	PipelineInitInfo ppinit;
-	ppinit.m_shaders[ShaderType::COMPUTE] = m_writeIndirectBuffComp->getGrShader();
-	m_updateIndirectBuffPpline = gr.newInstance<Pipeline>(ppinit);
-
-	ResourceGroupInitInfo rcinit;
-	rcinit.m_storageBuffers[0].m_buffer = m_queryResultBuff;
-	rcinit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_COMPUTE_READ;
-	rcinit.m_storageBuffers[1].m_buffer = m_indirectBuff;
-	rcinit.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_COMPUTE_WRITE;
-	m_updateIndirectBuffRsrc = gr.newInstance<ResourceGroup>(rcinit);
-
-	// Create ppline
-	// - only position attribute
-	// - points
-	// - test depth no write
-	// - will run after MS
-	// - will not update color
-	PipelineInitInfo init;
-	init.m_vertex.m_bindingCount = 1;
-	init.m_vertex.m_bindings[0].m_stride = sizeof(Vec3);
-	init.m_vertex.m_attributeCount = 1;
-	init.m_vertex.m_attributes[0].m_format = PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT);
-	init.m_inputAssembler.m_topology = PrimitiveTopology::POINTS;
-	init.m_depthStencil.m_depthWriteEnabled = false;
-	init.m_depthStencil.m_format = MS_DEPTH_ATTACHMENT_PIXEL_FORMAT;
-	ANKI_ASSERT(MS_COLOR_ATTACHMENT_COUNT == 3);
-	init.m_color.m_attachmentCount = MS_COLOR_ATTACHMENT_COUNT;
-	init.m_color.m_attachments[0].m_format = MS_COLOR_ATTACHMENT_PIXEL_FORMATS[0];
-	init.m_color.m_attachments[0].m_channelWriteMask = ColorBit::NONE;
-	init.m_color.m_attachments[1].m_format = MS_COLOR_ATTACHMENT_PIXEL_FORMATS[1];
-	init.m_color.m_attachments[1].m_channelWriteMask = ColorBit::NONE;
-	init.m_color.m_attachments[2].m_format = MS_COLOR_ATTACHMENT_PIXEL_FORMATS[2];
-	init.m_color.m_attachments[2].m_channelWriteMask = ColorBit::NONE;
-	init.m_shaders[ShaderType::VERTEX] = m_occlusionVert->getGrShader();
-	init.m_shaders[ShaderType::FRAGMENT] = m_occlusionFrag->getGrShader();
-	m_occlusionPpline = gr.newInstance<Pipeline>(init);
-
-	rcinit = ResourceGroupInitInfo();
-	rcinit.m_vertexBuffers[0].m_uploadedMemory = true;
-	rcinit.m_uniformBuffers[0].m_uploadedMemory = true;
-	rcinit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
-	m_occlusionRcGroup = gr.newInstance<ResourceGroup>(rcinit);
+	m_updateIndirectBuffProg = gr.newInstance<ShaderProgram>(m_writeIndirectBuffComp->getGrShader());
+
+	m_occlusionProg = gr.newInstance<ShaderProgram>(m_occlusionVert->getGrShader(), m_occlusionFrag->getGrShader());
 
 	return ErrorCode::NONE;
 }
@@ -191,21 +139,27 @@ void Lf::runOcclusionTests(RenderingContext& ctx, CommandBufferPtr cmdb)
 	const Vec3* initialPositions;
 	if(count)
 	{
-		TransientMemoryInfo dyn;
+		TransientMemoryToken uniToken, vertToken;
 
 		// Setup MVP UBO
-		Mat4* mvp = static_cast<Mat4*>(getGrManager().allocateFrameTransientMemory(
-			sizeof(Mat4), BufferUsageBit::UNIFORM_ALL, dyn.m_uniformBuffers[0]));
+		Mat4* mvp = static_cast<Mat4*>(
+			getGrManager().allocateFrameTransientMemory(sizeof(Mat4), BufferUsageBit::UNIFORM_ALL, uniToken));
 		*mvp = camFr.getViewProjectionMatrix();
 
 		// Alloc dyn mem
-		positions = static_cast<Vec3*>(getGrManager().allocateFrameTransientMemory(
-			sizeof(Vec3) * count, BufferUsageBit::VERTEX, dyn.m_vertexBuffers[0]));
+		positions = static_cast<Vec3*>(
+			getGrManager().allocateFrameTransientMemory(sizeof(Vec3) * count, BufferUsageBit::VERTEX, vertToken));
 		initialPositions = positions;
 
 		// Setup state
-		cmdb->bindPipeline(m_occlusionPpline);
-		cmdb->bindResourceGroup(m_occlusionRcGroup, 0, &dyn);
+		cmdb->bindShaderProgram(m_occlusionProg);
+		cmdb->bindUniformBuffer(0, 0, uniToken);
+		cmdb->bindVertexBuffer(0, vertToken, sizeof(Vec3));
+		cmdb->setVertexAttribute(0, 0, PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT), 0);
+		cmdb->setColorChannelWriteMask(0, ColorBit::NONE);
+		cmdb->setColorChannelWriteMask(1, ColorBit::NONE);
+		cmdb->setColorChannelWriteMask(2, ColorBit::NONE);
+		cmdb->setDepthWrite(false);
 	}
 
 	for(U i = 0; i < count; ++i)
@@ -218,11 +172,20 @@ void Lf::runOcclusionTests(RenderingContext& ctx, CommandBufferPtr cmdb)
 
 		// Draw and query
 		cmdb->beginOcclusionQuery(m_queries[i]);
-		cmdb->drawArrays(1, 1, positions - initialPositions);
+		cmdb->drawArrays(PrimitiveTopology::POINTS, 1, 1, positions - initialPositions);
 		cmdb->endOcclusionQuery(m_queries[i]);
 
 		++positions;
 	}
+
+	// Restore state
+	if(count)
+	{
+		cmdb->setColorChannelWriteMask(0, ColorBit::ALL);
+		cmdb->setColorChannelWriteMask(1, ColorBit::ALL);
+		cmdb->setColorChannelWriteMask(2, ColorBit::ALL);
+		cmdb->setDepthWrite(true);
+	}
 }
 
 void Lf::updateIndirectInfo(RenderingContext& ctx, CommandBufferPtr cmdb)
@@ -251,8 +214,9 @@ void Lf::updateIndirectInfo(RenderingContext& ctx, CommandBufferPtr cmdb)
 		sizeof(DrawArraysIndirectInfo) * count);
 
 	// Update the indirect info
-	cmdb->bindPipeline(m_updateIndirectBuffPpline);
-	cmdb->bindResourceGroup(m_updateIndirectBuffRsrc, 0, nullptr);
+	cmdb->bindShaderProgram(m_updateIndirectBuffProg);
+	cmdb->bindStorageBuffer(0, 0, m_queryResultBuff, 0);
+	cmdb->bindStorageBuffer(0, 1, m_indirectBuff, 0);
 	cmdb->dispatchCompute(count, 1, 1);
 
 	// Set barrier
@@ -269,13 +233,16 @@ void Lf::run(RenderingContext& ctx, CommandBufferPtr cmdb)
 	FrustumComponent& camFr = *ctx.m_frustumComponent;
 	VisibilityTestResults& vi = camFr.getVisibilityTestResults();
 
-	U count = min<U>(vi.getCount(VisibilityGroupType::FLARES), m_maxFlares);
+	const U count = min<U>(vi.getCount(VisibilityGroupType::FLARES), m_maxFlares);
 	if(count == 0)
 	{
 		return;
 	}
 
-	cmdb->bindPipeline(m_realPpline);
+	cmdb->bindShaderProgram(m_realProg);
+	cmdb->setDepthWrite(false);
+	cmdb->setDepthCompareFunction(CompareOperation::ALWAYS);
+
 	for(U i = 0; i < count; ++i)
 	{
 		auto it = vi.getBegin(VisibilityGroupType::FLARES) + i;
@@ -314,11 +281,16 @@ void Lf::run(RenderingContext& ctx, CommandBufferPtr cmdb)
 		++c;
 
 		// Render
-		TransientMemoryInfo dyn;
-		dyn.m_uniformBuffers[0] = token;
-		cmdb->bindResourceGroup(lf.getResourceGroup(), 0, &dyn);
-		cmdb->drawArraysIndirect(1, i * sizeof(DrawArraysIndirectInfo), m_indirectBuff);
+		cmdb->bindTexture(0, 0, lf.getTexture());
+		cmdb->bindUniformBuffer(0, 0, token);
+
+		cmdb->drawArraysIndirect(
+			PrimitiveTopology::TRIANGLE_STRIP, 1, i * sizeof(DrawArraysIndirectInfo), m_indirectBuff);
 	}
+
+	// Restore state
+	cmdb->setDepthWrite(true);
+	cmdb->setDepthCompareFunction(CompareOperation::LESS);
 }
 
 } // end namespace anki

src/anki/renderer/Lf.h

@@ -43,18 +43,16 @@ private:
 	BufferPtr m_queryResultBuff;
 	BufferPtr m_indirectBuff;
 	ShaderResourcePtr m_writeIndirectBuffComp;
-	PipelinePtr m_updateIndirectBuffPpline;
-	ResourceGroupPtr m_updateIndirectBuffRsrc;
+	ShaderProgramPtr m_updateIndirectBuffProg;
 
 	ShaderResourcePtr m_occlusionVert;
 	ShaderResourcePtr m_occlusionFrag;
-	PipelinePtr m_occlusionPpline;
-	ResourceGroupPtr m_occlusionRcGroup;
+	ShaderProgramPtr m_occlusionProg;
 
 	// Sprite billboards
 	ShaderResourcePtr m_realVert;
 	ShaderResourcePtr m_realFrag;
-	PipelinePtr m_realPpline;
+	ShaderProgramPtr m_realProg;
 	U8 m_maxSpritesPerFlare;
 	U8 m_maxFlares;
 	U16 m_maxSprites;

src/anki/renderer/MainRenderer.cpp

@@ -81,16 +81,8 @@ Error MainRenderer::create(ThreadPool* threadpool,
 	if(!m_rDrawToDefaultFb)
 	{
 		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/Final.frag.glsl", m_blitFrag));
+		m_r->createDrawQuadShaderProgram(m_blitFrag->getGrShader(), m_blitProg);
 
-		ColorStateInfo colorState;
-		colorState.m_attachmentCount = 1;
-		colorState.m_attachments[0].m_format.m_components = ComponentFormat::DEFAULT_FRAMEBUFFER;
-		m_r->createDrawQuadPipeline(m_blitFrag->getGrShader(), colorState, m_blitPpline);
-
-		// Init RC group
-		ResourceGroupInitInfo rcinit;
-		rcinit.m_textures[0].m_texture = m_r->getPps().getRt();
-		m_rcGroup = m_r->getGrManager().newInstance<ResourceGroup>(rcinit);
 		ANKI_LOGI("The main renderer will have to blit the offscreen renderer's result");
 	}
 
@@ -108,12 +100,11 @@ Error MainRenderer::render(SceneGraph& scene)
 
 	GrManager& gl = m_r->getGrManager();
 	CommandBufferInitInfo cinf;
+	cinf.m_flags =
+		CommandBufferFlag::COMPUTE_WORK | CommandBufferFlag::GRAPHICS_WORK | CommandBufferFlag::TRANSFER_WORK;
 	cinf.m_hints = m_cbInitHints;
 	CommandBufferPtr cmdb = gl.newInstance<CommandBuffer>(cinf);
 
-	// Set some of the dynamic state
-	cmdb->setPolygonOffset(0.0, 0.0);
-
 	// Run renderer
 	RenderingContext ctx(m_frameAlloc);
 
@@ -134,8 +125,8 @@ Error MainRenderer::render(SceneGraph& scene)
 		cmdb->beginRenderPass(m_defaultFb);
 		cmdb->setViewport(0, 0, m_width, m_height);
 
-		cmdb->bindPipeline(m_blitPpline);
-		cmdb->bindResourceGroup(m_rcGroup, 0, nullptr);
+		cmdb->bindShaderProgram(m_blitProg);
+		cmdb->bindTexture(0, 0, m_r->getPps().getRt());
 
 		m_r->drawQuad(cmdb);
 		cmdb->endRenderPass();

src/anki/renderer/MainRenderer.h

@@ -67,8 +67,7 @@ private:
 	Bool8 m_rDrawToDefaultFb = false;
 
 	ShaderResourcePtr m_blitFrag;
-	PipelinePtr m_blitPpline;
-	ResourceGroupPtr m_rcGroup;
+	ShaderProgramPtr m_blitProg;
 
 	FramebufferPtr m_defaultFb;
 	U32 m_width = 0; ///< Default FB size.

src/anki/renderer/Renderer.cpp

@@ -20,7 +20,6 @@
 #include <anki/renderer/Fs.h>
 #include <anki/renderer/Lf.h>
 #include <anki/renderer/Dbg.h>
-#include <anki/renderer/Tiler.h>
 #include <anki/renderer/FsUpscale.h>
 #include <anki/renderer/DownscaleBlur.h>
 #include <anki/renderer/Volumetric.h>
@@ -372,22 +371,6 @@ void Renderer::clearRenderTarget(TexturePtr rt, const ClearValue& clear, Texture
 	cmdb->flush();
 }
 
-void Renderer::createDrawQuadPipeline(ShaderPtr frag, const ColorStateInfo& colorState, PipelinePtr& ppline)
-{
-	PipelineInitInfo init;
-
-	init.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
-
-	init.m_depthStencil.m_depthWriteEnabled = false;
-	init.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
-
-	init.m_color = colorState;
-
-	init.m_shaders[ShaderType::VERTEX] = m_drawQuadVert->getGrShader();
-	init.m_shaders[ShaderType::FRAGMENT] = frag;
-	ppline = m_gr->newInstance<Pipeline>(init);
-}
-
 Error Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId, PtrSize threadCount)
 {
 	// MS
@@ -522,4 +505,9 @@ Error Renderer::createShaderf(CString fname, ShaderResourcePtr& shader, CString
 	return m_resources->loadResourceToCache(shader, fname, &buffer[0], "r_");
 }
 
+void Renderer::createDrawQuadShaderProgram(ShaderPtr frag, ShaderProgramPtr& prog)
+{
+	prog = m_gr->newInstance<ShaderProgram>(m_drawQuadVert->getGrShader(), frag);
+}
+
 } // end namespace anki

src/anki/resource/Model.cpp

@@ -47,31 +47,26 @@ void ModelPatch::getRenderingDataSub(
 		inf.m_vertexBufferBindingCount = 1;
 		VertexBufferBinding& vertBuffBinding = inf.m_vertexBufferBindings[0];
 		vertBuffBinding.m_buffer = mesh.getVertexBuffer();
-		vertBuffBinding.m_binding = 0;
 		vertBuffBinding.m_offset = 0;
 		vertBuffBinding.m_stride = sizeof(Vec3) + sizeof(HVec2) + 2 * sizeof(U32);
 
 		inf.m_vertexAttributeCount = 4;
 		auto& attribs = inf.m_vertexAttributes;
 
-		attribs[0].m_location = 0;
 		attribs[0].m_bufferBinding = 0;
 		attribs[0].m_format = PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT);
 		attribs[0].m_relativeOffset = 0;
 
-		attribs[1].m_location = 0;
 		attribs[1].m_bufferBinding = 0;
 		attribs[1].m_format = PixelFormat(ComponentFormat::R16G16, TransformFormat::FLOAT);
 		attribs[1].m_relativeOffset = sizeof(Vec3);
 
 		if(key.m_pass == Pass::MS_FS)
 		{
-			attribs[2].m_location = 0;
 			attribs[2].m_bufferBinding = 0;
 			attribs[2].m_format = PixelFormat(ComponentFormat::R10G10B10A2, TransformFormat::SNORM);
 			attribs[2].m_relativeOffset = sizeof(Vec3) + sizeof(U32);
 
-			attribs[3].m_location = 0;
 			attribs[3].m_bufferBinding = 0;
 			attribs[3].m_format = PixelFormat(ComponentFormat::R10G10B10A2, TransformFormat::SNORM);
 			attribs[3].m_relativeOffset = sizeof(Vec3) + sizeof(U32) * 2;

src/anki/scene/ParticleEmitter.cpp

@@ -290,20 +290,16 @@ Error ParticleEmitter::buildRendering(const RenderingBuildInfoIn& in, RenderingB
 
 	out.m_vertexBufferBindingCount = 1;
 	out.m_vertexBufferBindings[0].m_buffer = m_vertBuffs[frame];
-	out.m_vertexBufferBindings[0].m_binding = 0;
 	out.m_vertexBufferBindings[0].m_offset = 0;
 	out.m_vertexBufferBindings[0].m_stride = VERTEX_SIZE;
 
 	out.m_vertexAttributeCount = 3;
-	out.m_vertexAttributes[0].m_location = 0;
 	out.m_vertexAttributes[0].m_bufferBinding = 0;
 	out.m_vertexAttributes[0].m_format = PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT);
 	out.m_vertexAttributes[0].m_relativeOffset = 0;
-	out.m_vertexAttributes[1].m_location = 1;
 	out.m_vertexAttributes[1].m_bufferBinding = 0;
 	out.m_vertexAttributes[1].m_format = PixelFormat(ComponentFormat::R32, TransformFormat::FLOAT);
 	out.m_vertexAttributes[1].m_relativeOffset = sizeof(Vec3);
-	out.m_vertexAttributes[2].m_location = 2;
 	out.m_vertexAttributes[2].m_bufferBinding = 0;
 	out.m_vertexAttributes[2].m_format = PixelFormat(ComponentFormat::R32, TransformFormat::FLOAT);
 	out.m_vertexAttributes[2].m_relativeOffset = sizeof(Vec3) + sizeof(F32);

src/anki/ui/UiInterfaceImpl.cpp

@@ -33,7 +33,8 @@ Error UiInterfaceImpl::init(GrManager* gr, ResourceManager* rc)
 
 	ANKI_CHECK(rc->loadResource("shaders/UiLines.frag.glsl", m_stages[StageId::LINES].m_fShader));
 
-	// Init pplines
+// Init pplines
+#if 0
 	PipelineInitInfo ppinit;
 	ppinit.m_vertex.m_bindingCount = 1;
 	ppinit.m_vertex.m_bindings[0].m_stride = sizeof(Vertex);
@@ -58,6 +59,7 @@ Error UiInterfaceImpl::init(GrManager* gr, ResourceManager* rc)
 	ppinit.m_shaders[U(ShaderType::VERTEX)] = m_stages[StageId::LINES].m_vShader->getGrShader();
 	ppinit.m_shaders[U(ShaderType::FRAGMENT)] = m_stages[StageId::LINES].m_fShader->getGrShader();
 	m_stages[StageId::LINES].m_ppline = gr->newInstance<Pipeline>(ppinit);
+#endif
 
 	// Init buffers
 	for(U s = 0; s < StageId::COUNT; ++s)
@@ -69,7 +71,8 @@ Error UiInterfaceImpl::init(GrManager* gr, ResourceManager* rc)
 		}
 	}
 
-	// Init resource groups
+// Init resource groups
+#if 0
 	for(U s = 0; s < StageId::COUNT; ++s)
 	{
 		for(U i = 0; i < m_stages[s].m_rcGroups.getSize(); ++i)
@@ -85,6 +88,7 @@ Error UiInterfaceImpl::init(GrManager* gr, ResourceManager* rc)
 			m_stages[s].m_rcGroups[i] = gr->newInstance<ResourceGroup>(rcinit);
 		}
 	}
+#endif
 
 	return ErrorCode::NONE;
 }
@@ -123,9 +127,9 @@ void UiInterfaceImpl::drawLines(const WeakArray<UVec2>& positions, const Color&
 
 	ANKI_ASSERT(m_vertCounts[stageId] + positions.getSize() <= MAX_VERTS);
 
-	m_cmdb->bindPipeline(m_stages[StageId::LINES].m_ppline);
-	m_cmdb->bindResourceGroup(m_stages[StageId::LINES].m_rcGroups[m_timestamp], 0, nullptr);
-	m_cmdb->drawArrays(positions.getSize(), 1, m_vertCounts[stageId]);
+	// m_cmdb->bindPipeline(m_stages[StageId::LINES].m_ppline);
+	// m_cmdb->bindResourceGroup(m_stages[StageId::LINES].m_rcGroups[m_timestamp], 0, nullptr);
+	// m_cmdb->drawArrays(positions.getSize(), 1, m_vertCounts[stageId]);
 
 	for(const UVec2& pos : positions)
 	{

src/anki/ui/UiInterfaceImpl.h

@@ -75,9 +75,7 @@ private:
 	public:
 		ShaderResourcePtr m_vShader;
 		ShaderResourcePtr m_fShader;
-		PipelinePtr m_ppline;
 		Array<BufferPtr, MAX_FRAMES_IN_FLIGHT> m_vertBuffs;
-		Array<ResourceGroupPtr, MAX_FRAMES_IN_FLIGHT> m_rcGroups;
 	};
 
 	Array<Stage, StageId::COUNT> m_stages;