Add MDI to the RenderableDrawer

AnKi/Gr/CommandBuffer.h

@@ -285,7 +285,7 @@ public:
 	void drawIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* indirectBuff);
 
 	void drawIndexedIndirectCount(PrimitiveTopology topology, Buffer* argBuffer, PtrSize argBufferOffset, Buffer* countBuffer,
-								  PtrSize countBufferOffset);
+								  PtrSize countBufferOffset, U32 maxDrawCount);
 
 	void dispatchCompute(U32 groupCountX, U32 groupCountY, U32 groupCountZ);
 

AnKi/Gr/RenderGraph.cpp

@@ -1256,12 +1256,12 @@ void RenderGraph::runSecondLevel(U32 threadIdx)
 			ANKI_ASSERT(!p.m_secondLevelCmdbs[threadIdx].isCreated());
 			p.m_secondLevelCmdbs[threadIdx] = GrManager::getSingleton().newCommandBuffer(p.m_secondLevelCmdbInitInfo);
 
-			ctx.m_commandBuffer = p.m_secondLevelCmdbs[threadIdx];
+			ctx.m_commandBuffer = p.m_secondLevelCmdbs[threadIdx].get();
 			ctx.m_secondLevelCommandBufferCount = size;
 			ctx.m_passIdx = U32(&p - &m_ctx->m_passes[0]);
 			ctx.m_batchIdx = p.m_batchIdx;
 
-			ANKI_ASSERT(ctx.m_commandBuffer.isCreated());
+			ANKI_ASSERT(ctx.m_commandBuffer);
 
 			{
 				ANKI_TRACE_SCOPED_EVENT(GrRenderGraphCallback);
@@ -1287,8 +1287,8 @@ void RenderGraph::run() const
 
 	for(const Batch& batch : m_ctx->m_batches)
 	{
-		ctx.m_commandBuffer.reset(batch.m_cmdb);
-		CommandBufferPtr& cmdb = ctx.m_commandBuffer;
+		ctx.m_commandBuffer = batch.m_cmdb;
+		CommandBuffer& cmdb = *ctx.m_commandBuffer;
 
 		// Set the barriers
 		DynamicArray<TextureBarrierInfo, MemoryPoolPtrWrapper<StackMemoryPool>> texBarriers(pool);
@@ -1321,7 +1321,7 @@ void RenderGraph::run() const
 			inf.m_nextUsage = barrier.m_usageAfter;
 			inf.m_as = m_ctx->m_as[barrier.m_idx].m_as.get();
 		}
-		cmdb->setPipelineBarrier(texBarriers, buffBarriers, asBarriers);
+		cmdb.setPipelineBarrier(texBarriers, buffBarriers, asBarriers);
 
 		// Call the passes
 		for(U32 passIdx : batch.m_passIndices)
@@ -1330,8 +1330,8 @@ void RenderGraph::run() const
 
 			if(pass.m_framebuffer)
 			{
-				cmdb->beginRenderPass(pass.m_framebuffer.get(), pass.m_colorUsages, pass.m_dsUsage, pass.m_fbRenderArea[0], pass.m_fbRenderArea[1],
-									  pass.m_fbRenderArea[2], pass.m_fbRenderArea[3]);
+				cmdb.beginRenderPass(pass.m_framebuffer.get(), pass.m_colorUsages, pass.m_dsUsage, pass.m_fbRenderArea[0], pass.m_fbRenderArea[1],
+									 pass.m_fbRenderArea[2], pass.m_fbRenderArea[3]);
 			}
 
 			const U32 size = pass.m_secondLevelCmdbs.getSize();
@@ -1351,12 +1351,12 @@ void RenderGraph::run() const
 				{
 					cmdbs.emplaceBack(cmdb2nd.get());
 				}
-				cmdb->pushSecondLevelCommandBuffers(cmdbs);
+				cmdb.pushSecondLevelCommandBuffers(cmdbs);
 			}
 
 			if(pass.m_framebuffer)
 			{
-				cmdb->endRenderPass();
+				cmdb.endRenderPass();
 			}
 		}
 	}

AnKi/Gr/RenderGraph.h

@@ -117,9 +117,9 @@ class RenderPassWorkContext
 	friend class RenderGraph;
 
 public:
-	CommandBufferPtr m_commandBuffer;
-	U32 m_currentSecondLevelCommandBufferIndex ANKI_DEBUG_CODE(= 0);
-	U32 m_secondLevelCommandBufferCount ANKI_DEBUG_CODE(= 0);
+	CommandBuffer* m_commandBuffer = nullptr;
+	U32 m_currentSecondLevelCommandBufferIndex = 0;
+	U32 m_secondLevelCommandBufferCount = 0;
 
 	void getBufferState(BufferHandle handle, Buffer*& buff, PtrSize& offset, PtrSize& range) const;
 

AnKi/Gr/Vulkan/CommandBuffer.cpp

@@ -275,10 +275,10 @@ void CommandBuffer::drawIndirect(PrimitiveTopology topology, U32 drawCount, PtrS
 }
 
 void CommandBuffer::drawIndexedIndirectCount(PrimitiveTopology topology, Buffer* argBuffer, PtrSize argBufferOffset, Buffer* countBuffer,
-											 PtrSize countBufferOffset)
+											 PtrSize countBufferOffset, U32 maxDrawCount)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.drawIndexedIndirectCountInternal(topology, argBuffer, argBufferOffset, countBuffer, countBufferOffset);
+	self.drawIndexedIndirectCountInternal(topology, argBuffer, argBufferOffset, countBuffer, countBufferOffset, maxDrawCount);
 }
 
 void CommandBuffer::drawIndexedIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* buff)

AnKi/Gr/Vulkan/CommandBufferImpl.h

@@ -322,7 +322,7 @@ public:
 	}
 
 	ANKI_FORCE_INLINE void drawIndexedIndirectCountInternal(PrimitiveTopology topology, Buffer* argBuffer, PtrSize argBufferOffset,
-															Buffer* countBuffer, PtrSize countBufferOffset)
+															Buffer* countBuffer, PtrSize countBufferOffset, U32 maxDrawCount)
 	{
 		m_state.setPrimitiveTopology(topology);
 		drawcallCommon();
@@ -334,8 +334,10 @@ public:
 		ANKI_ASSERT(countBufferImpl.usageValid(BufferUsageBit::kIndirectDraw));
 		ANKI_ASSERT((countBufferOffset % 4) == 0);
 
+		ANKI_ASSERT(maxDrawCount > 0 && maxDrawCount <= getGrManagerImpl().getDeviceCapabilities().m_maxDrawIndirectCount);
+
 		vkCmdDrawIndexedIndirectCountKHR(m_handle, argBufferImpl.getHandle(), argBufferOffset, countBufferImpl.getHandle(), countBufferOffset,
-										 kMaxU32, sizeof(DrawIndexedIndirectArgs));
+										 maxDrawCount, sizeof(DrawIndexedIndirectArgs));
 	}
 
 	void dispatchComputeInternal(U32 groupCountX, U32 groupCountY, U32 groupCountZ);

AnKi/Renderer/Bloom.cpp

@@ -126,18 +126,18 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_exposure.m_grProg.get());
+			cmdb.bindShaderProgram(m_exposure.m_grProg.get());
 
 			TextureSubresourceInfo inputTexSubresource;
 			inputTexSubresource.m_firstMipmap = getRenderer().getDownscaleBlur().getMipmapCount() - 1;
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(0, 1, getRenderer().getDownscaleBlur().getRt(), inputTexSubresource);
 
 			const Vec4 uniforms(ConfigSet::getSingleton().getRBloomThreshold(), ConfigSet::getSingleton().getRBloomScale(), 0.0f, 0.0f);
-			cmdb->setPushConstants(&uniforms, sizeof(uniforms));
+			cmdb.setPushConstants(&uniforms, sizeof(uniforms));
 
 			rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
 
@@ -149,9 +149,9 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				cmdb->setViewport(0, 0, m_exposure.m_width, m_exposure.m_height);
+				cmdb.setViewport(0, 0, m_exposure.m_width, m_exposure.m_height);
 
-				cmdb->draw(PrimitiveTopology::kTriangles, 3);
+				cmdb.draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}
@@ -184,13 +184,13 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_upscale.m_grProg.get());
+			cmdb.bindShaderProgram(m_upscale.m_grProg.get());
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_exposureRt);
-			cmdb->bindTexture(0, 2, &m_upscale.m_lensDirtImage->getTextureView());
+			cmdb.bindTexture(0, 2, &m_upscale.m_lensDirtImage->getTextureView());
 
 			if(ConfigSet::getSingleton().getRPreferCompute())
 			{
@@ -200,9 +200,9 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				cmdb->setViewport(0, 0, m_upscale.m_width, m_upscale.m_height);
+				cmdb.setViewport(0, 0, m_upscale.m_width, m_upscale.m_height);
 
-				cmdb->draw(PrimitiveTopology::kTriangles, 3);
+				cmdb.draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}

AnKi/Renderer/ClusterBinning.cpp

@@ -73,9 +73,9 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	pass.newBufferDependency(m_runCtx.m_rebarHandle, BufferUsageBit::kStorageComputeWrite);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
-		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg.get());
+		cmdb.bindShaderProgram(m_grProg.get());
 
 		bindUniforms(cmdb, 0, 0, m_runCtx.m_clusteredShadingUniformsToken);
 		bindStorage(cmdb, 0, 1, m_runCtx.m_clustersToken);
@@ -94,7 +94,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		clusterObjectCounts += rqueue.m_giProbes.getSize();
 		clusterObjectCounts += rqueue.m_fogDensityVolumes.getSize();
 		clusterObjectCounts += rqueue.m_decals.getSize();
-		cmdb->dispatchCompute((sizex + 64 - 1) / 64, clusterObjectCounts, 1);
+		cmdb.dispatchCompute((sizex + 64 - 1) / 64, clusterObjectCounts, 1);
 	});
 }
 

AnKi/Renderer/Dbg.cpp

@@ -58,18 +58,18 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 {
 	ANKI_ASSERT(ConfigSet::getSingleton().getRDbg());
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	// Set common state
-	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
-	cmdb->setDepthWrite(false);
+	cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
+	cmdb.setDepthWrite(false);
 
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 	rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
-	cmdb->setDepthCompareOperation((m_depthTestOn) ? CompareOperation::kLess : CompareOperation::kAlways);
+	cmdb.setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
+	cmdb.setDepthCompareOperation((m_depthTestOn) ? CompareOperation::kLess : CompareOperation::kAlways);
 
 	// Draw renderables
 	const U32 threadId = rgraphCtx.m_currentSecondLevelCommandBufferIndex;
@@ -226,7 +226,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 	}
 
 	// Restore state
-	cmdb->setDepthCompareOperation(CompareOperation::kLess);
+	cmdb.setDepthCompareOperation(CompareOperation::kLess);
 }
 
 void Dbg::populateRenderGraph(RenderingContext& ctx)

AnKi/Renderer/DebugDrawer.cpp

@@ -135,7 +135,7 @@ Error DebugDrawer2::init()
 }
 
 void DebugDrawer2::drawCubes(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, F32 cubeSideSize,
-							 CommandBufferPtr& cmdb) const
+							 CommandBuffer& cmdb) const
 {
 	// Set the uniforms
 	RebarAllocation unisToken;
@@ -156,23 +156,23 @@ void DebugDrawer2::drawCubes(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 l
 	variantInitInfo.addMutation("DITHERED_DEPTH_TEST", U32(ditherFailedDepth != 0));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	cmdb->bindShaderProgram(&variant->getProgram());
+	cmdb.bindShaderProgram(&variant->getProgram());
 
-	cmdb->setPushConstants(&color, sizeof(color));
+	cmdb.setPushConstants(&color, sizeof(color));
 
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->bindVertexBuffer(0, m_cubePositionsBuffer.get(), 0, sizeof(Vec3));
-	cmdb->bindIndexBuffer(m_cubeIndicesBuffer.get(), 0, IndexType::kU16);
+	cmdb.setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb.bindVertexBuffer(0, m_cubePositionsBuffer.get(), 0, sizeof(Vec3));
+	cmdb.bindIndexBuffer(m_cubeIndicesBuffer.get(), 0, IndexType::kU16);
 
-	cmdb->bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
+	cmdb.bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
 
-	cmdb->setLineWidth(lineSize);
+	cmdb.setLineWidth(lineSize);
 	constexpr U kIndexCount = 12 * 2;
-	cmdb->drawIndexed(PrimitiveTopology::kLines, kIndexCount, mvps.getSize());
+	cmdb.drawIndexed(PrimitiveTopology::kLines, kIndexCount, mvps.getSize());
 }
 
 void DebugDrawer2::drawLines(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, ConstWeakArray<Vec3> linePositions,
-							 CommandBufferPtr& cmdb) const
+							 CommandBuffer& cmdb) const
 {
 	ANKI_ASSERT(mvps.getSize() > 0);
 	ANKI_ASSERT(linePositions.getSize() > 0 && (linePositions.getSize() % 2) == 0);
@@ -193,21 +193,21 @@ void DebugDrawer2::drawLines(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 l
 	variantInitInfo.addMutation("DITHERED_DEPTH_TEST", U32(ditherFailedDepth != 0));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	cmdb->bindShaderProgram(&variant->getProgram());
+	cmdb.bindShaderProgram(&variant->getProgram());
 
-	cmdb->setPushConstants(&color, sizeof(color));
+	cmdb.setPushConstants(&color, sizeof(color));
 
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), vertsToken.m_offset, sizeof(Vec3));
+	cmdb.setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb.bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), vertsToken.m_offset, sizeof(Vec3));
 
-	cmdb->bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
+	cmdb.bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
 
-	cmdb->setLineWidth(lineSize);
-	cmdb->draw(PrimitiveTopology::kLines, linePositions.getSize(), mvps.getSize());
+	cmdb.setLineWidth(lineSize);
+	cmdb.draw(PrimitiveTopology::kLines, linePositions.getSize(), mvps.getSize());
 }
 
 void DebugDrawer2::drawBillboardTextures(const Mat4& projMat, const Mat3x4& viewMat, ConstWeakArray<Vec3> positions, const Vec4& color,
-										 Bool ditherFailedDepth, TextureView* tex, Sampler* sampler, Vec2 billboardSize, CommandBufferPtr& cmdb) const
+										 Bool ditherFailedDepth, TextureView* tex, Sampler* sampler, Vec2 billboardSize, CommandBuffer& cmdb) const
 {
 	RebarAllocation positionsToken;
 	Vec3* verts = static_cast<Vec3*>(RebarTransientMemoryPool::getSingleton().allocateFrame(sizeof(Vec3) * 4, positionsToken));
@@ -256,20 +256,20 @@ void DebugDrawer2::drawBillboardTextures(const Mat4& projMat, const Mat3x4& view
 	variantInitInfo.addMutation("DITHERED_DEPTH_TEST", U32(ditherFailedDepth != 0));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	cmdb->bindShaderProgram(&variant->getProgram());
+	cmdb.bindShaderProgram(&variant->getProgram());
 
-	cmdb->setPushConstants(&color, sizeof(color));
+	cmdb.setPushConstants(&color, sizeof(color));
 
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->setVertexAttribute(1, 1, Format::kR32G32_Sfloat, 0);
-	cmdb->bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), positionsToken.m_offset, sizeof(Vec3));
-	cmdb->bindVertexBuffer(1, &RebarTransientMemoryPool::getSingleton().getBuffer(), uvsToken.m_offset, sizeof(Vec2));
+	cmdb.setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb.setVertexAttribute(1, 1, Format::kR32G32_Sfloat, 0);
+	cmdb.bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), positionsToken.m_offset, sizeof(Vec3));
+	cmdb.bindVertexBuffer(1, &RebarTransientMemoryPool::getSingleton().getBuffer(), uvsToken.m_offset, sizeof(Vec2));
 
-	cmdb->bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
-	cmdb->bindSampler(0, 3, sampler);
-	cmdb->bindTexture(0, 4, tex);
+	cmdb.bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
+	cmdb.bindSampler(0, 3, sampler);
+	cmdb.bindTexture(0, 4, tex);
 
-	cmdb->draw(PrimitiveTopology::kTriangleStrip, 4, positions.getSize());
+	cmdb.draw(PrimitiveTopology::kTriangleStrip, 4, positions.getSize());
 }
 
 void PhysicsDebugDrawer::drawLines(const Vec3* lines, const U32 vertCount, const Vec4& color)
@@ -296,7 +296,7 @@ void PhysicsDebugDrawer::flush()
 {
 	if(m_vertCount > 0)
 	{
-		m_dbg->drawLines(ConstWeakArray<Mat4>(&m_mvp, 1), m_currentColor, 2.0f, false, ConstWeakArray<Vec3>(&m_vertCache[0], m_vertCount), m_cmdb);
+		m_dbg->drawLines(ConstWeakArray<Mat4>(&m_mvp, 1), m_currentColor, 2.0f, false, ConstWeakArray<Vec3>(&m_vertCache[0], m_vertCount), *m_cmdb);
 
 		m_vertCount = 0;
 	}

AnKi/Renderer/DebugDrawer.h

@@ -35,29 +35,27 @@ public:
 		return m_prog.isCreated();
 	}
 
-	void drawCubes(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, F32 cubeSideSize,
-				   CommandBufferPtr& cmdb) const;
+	void drawCubes(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, F32 cubeSideSize, CommandBuffer& cmdb) const;
 
-	void drawCube(const Mat4& mvp, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, F32 cubeSideSize, CommandBufferPtr& cmdb) const
+	void drawCube(const Mat4& mvp, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, F32 cubeSideSize, CommandBuffer& cmdb) const
 	{
 		drawCubes(ConstWeakArray<Mat4>(&mvp, 1), color, lineSize, ditherFailedDepth, cubeSideSize, cmdb);
 	}
 
 	void drawLines(ConstWeakArray<Mat4> mvps, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, ConstWeakArray<Vec3> linePositions,
-				   CommandBufferPtr& cmdb) const;
+				   CommandBuffer& cmdb) const;
 
-	void drawLine(const Mat4& mvp, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, const Vec3& a, const Vec3& b,
-				  CommandBufferPtr& cmdb) const
+	void drawLine(const Mat4& mvp, const Vec4& color, F32 lineSize, Bool ditherFailedDepth, const Vec3& a, const Vec3& b, CommandBuffer& cmdb) const
 	{
 		Array<Vec3, 2> points = {a, b};
 		drawLines(ConstWeakArray<Mat4>(&mvp, 1), color, lineSize, ditherFailedDepth, points, cmdb);
 	}
 
 	void drawBillboardTextures(const Mat4& projMat, const Mat3x4& viewMat, ConstWeakArray<Vec3> positions, const Vec4& color, Bool ditherFailedDepth,
-							   TextureView* tex, Sampler* sampler, Vec2 billboardSize, CommandBufferPtr& cmdb) const;
+							   TextureView* tex, Sampler* sampler, Vec2 billboardSize, CommandBuffer& cmdb) const;
 
 	void drawBillboardTexture(const Mat4& projMat, const Mat3x4& viewMat, Vec3 position, const Vec4& color, Bool ditherFailedDepth, TextureView* tex,
-							  Sampler* sampler, Vec2 billboardSize, CommandBufferPtr& cmdb) const
+							  Sampler* sampler, Vec2 billboardSize, CommandBuffer& cmdb) const
 	{
 		drawBillboardTextures(projMat, viewMat, ConstWeakArray<Vec3>(&position, 1), color, ditherFailedDepth, tex, sampler, billboardSize, cmdb);
 	}
@@ -77,11 +75,11 @@ public:
 	{
 	}
 
-	void start(const Mat4& mvp, CommandBufferPtr& cmdb)
+	void start(const Mat4& mvp, CommandBuffer& cmdb)
 	{
 		ANKI_ASSERT(m_vertCount == 0);
 		m_mvp = mvp;
-		m_cmdb = cmdb;
+		m_cmdb.reset(&cmdb);
 	}
 
 	void drawLines(const Vec3* lines, const U32 vertCount, const Vec4& color) final;

AnKi/Renderer/DepthDownscale.cpp

@@ -234,21 +234,21 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	// Zero the counter buffer before everything else
 	if(!m_counterBufferZeroed) [[unlikely]]
 	{
 		m_counterBufferZeroed = true;
 
-		cmdb->fillBuffer(m_counterBuffer.get(), 0, kMaxPtrSize, 0);
+		cmdb.fillBuffer(m_counterBuffer.get(), 0, kMaxPtrSize, 0);
 
 		const BufferBarrierInfo barrier = {m_counterBuffer.get(), BufferUsageBit::kTransferDestination, BufferUsageBit::kStorageComputeWrite, 0,
 										   kMaxPtrSize};
-		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
+		cmdb.setPipelineBarrier({}, {&barrier, 1}, {});
 	}
 
-	cmdb->bindShaderProgram(m_grProg.get());
+	cmdb.bindShaderProgram(m_grProg.get());
 
 	varAU2(dispatchThreadGroupCountXY);
 	varAU2(workGroupOffset); // needed if Left and Top are not 0,0
@@ -263,7 +263,7 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 	pc.m_srcTexSizeOverOne = 1.0f / Vec2(getRenderer().getInternalResolution());
 	pc.m_lastMipWidth = m_lastMipSize.x();
 
-	cmdb->setPushConstants(&pc, sizeof(pc));
+	cmdb.setPushConstants(&pc, sizeof(pc));
 
 	constexpr U32 maxMipsSpdCanProduce = 12;
 	for(U32 mip = 0; mip < maxMipsSpdCanProduce; ++mip)
@@ -295,26 +295,26 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 		rgraphCtx.bindImage(0, 1, m_runCtx.m_hizRt, subresource);
 	}
 
-	cmdb->bindStorageBuffer(0, 2, m_counterBuffer.get(), 0, kMaxPtrSize);
-	cmdb->bindStorageBuffer(0, 3, m_clientBuffer.get(), 0, kMaxPtrSize);
+	cmdb.bindStorageBuffer(0, 2, m_counterBuffer.get(), 0, kMaxPtrSize);
+	cmdb.bindStorageBuffer(0, 3, m_clientBuffer.get(), 0, kMaxPtrSize);
 
-	cmdb->bindSampler(0, 4, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindTexture(0, 5, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	cmdb->dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
+	cmdb.dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
 }
 
 void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	if(mip == 0)
 	{
 		rgraphCtx.bindTexture(0, 0, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
-		cmdb->bindShaderProgram(m_firstMipGrProg.get());
+		cmdb.bindShaderProgram(m_firstMipGrProg.get());
 	}
 	else
 	{
@@ -324,24 +324,24 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 
 		if(m_reductionSampler.isCreated())
 		{
-			cmdb->bindSampler(0, 1, m_reductionSampler.get());
+			cmdb.bindSampler(0, 1, m_reductionSampler.get());
 		}
 		else
 		{
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 		}
 
-		cmdb->bindShaderProgram(m_grProg.get());
+		cmdb.bindShaderProgram(m_grProg.get());
 	}
 
-	cmdb->bindStorageBuffer(0, 2, m_clientBuffer.get(), 0, kMaxPtrSize);
+	cmdb.bindStorageBuffer(0, 2, m_clientBuffer.get(), 0, kMaxPtrSize);
 
 	const UVec4 pc((mip != m_mipCount - 1) ? 0 : m_lastMipSize.x());
-	cmdb->setPushConstants(&pc, sizeof(pc));
+	cmdb.setPushConstants(&pc, sizeof(pc));
 
 	const UVec2 size = (getRenderer().getInternalResolution() / 2) >> mip;
-	cmdb->setViewport(0, 0, size.x(), size.y());
-	cmdb->draw(PrimitiveTopology::kTriangles, 3);
+	cmdb.setViewport(0, 0, size.x(), size.y());
+	cmdb.draw(PrimitiveTopology::kTriangles, 3);
 }
 
 } // end namespace anki

AnKi/Renderer/DownscaleBlur.cpp

@@ -146,14 +146,14 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 
 void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg.get());
+	cmdb.bindShaderProgram(m_grProg.get());
 
 	const U32 vpWidth = m_rtTex->getWidth() >> passIdx;
 	const U32 vpHeight = m_rtTex->getHeight() >> passIdx;
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 
 	if(passIdx > 0)
 	{
@@ -172,7 +172,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 
 	const Bool revertTonemap = passIdx == 0 && !getRenderer().getScale().hasUpscaledHdrRt();
 	const UVec4 fbSize(vpWidth, vpHeight, revertTonemap, 0);
-	cmdb->setPushConstants(&fbSize, sizeof(fbSize));
+	cmdb.setPushConstants(&fbSize, sizeof(fbSize));
 
 	if(ConfigSet::getSingleton().getRPreferCompute())
 	{
@@ -184,9 +184,9 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, vpWidth, vpHeight);
+		cmdb.setViewport(0, 0, vpWidth, vpHeight);
 
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/Drawer.cpp

@@ -14,6 +14,7 @@
 #include <AnKi/Core/GpuMemory/UnifiedGeometryBuffer.h>
 #include <AnKi/Core/GpuMemory/RebarTransientMemoryPool.h>
 #include <AnKi/Core/GpuMemory/GpuSceneBuffer.h>
+#include <AnKi/Scene/RenderStateBucket.h>
 
 namespace anki {
 
@@ -21,8 +22,6 @@ namespace anki {
 class RenderableDrawer::Context
 {
 public:
-	CommandBufferPtr m_commandBuffer;
-
 	Array<const RenderableQueueElement*, kMaxInstanceCount> m_cachedRenderElements;
 	U32 m_cachedRenderElementCount = 0;
 	ShaderProgram* m_lastBoundShaderProgram = nullptr;
@@ -32,11 +31,8 @@ RenderableDrawer::~RenderableDrawer()
 {
 }
 
-void RenderableDrawer::drawRange(const RenderableDrawerArguments& args, const RenderableQueueElement* begin, const RenderableQueueElement* end,
-								 CommandBufferPtr& cmdb)
+void RenderableDrawer::setState(const RenderableDrawerArguments& args, CommandBuffer& cmdb)
 {
-	ANKI_ASSERT(begin && end && begin < end);
-
 	// Allocate, set and bind global uniforms
 	{
 		RebarAllocation globalUniformsToken;
@@ -50,41 +46,44 @@ void RenderableDrawer::drawRange(const RenderableDrawerArguments& args, const Re
 		static_assert(sizeof(globalUniforms->m_cameraTransform) == sizeof(args.m_cameraTransform));
 		memcpy(&globalUniforms->m_cameraTransform, &args.m_cameraTransform, sizeof(args.m_cameraTransform));
 
-		cmdb->bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms),
-								&RebarTransientMemoryPool::getSingleton().getBuffer(), globalUniformsToken.m_offset, globalUniformsToken.m_range);
+		cmdb.bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms),
+							   &RebarTransientMemoryPool::getSingleton().getBuffer(), globalUniformsToken.m_offset, globalUniformsToken.m_range);
 	}
 
 	// More globals
-	cmdb->bindAllBindless(U32(MaterialSet::kBindless));
-	cmdb->bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler), args.m_sampler);
-	cmdb->bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindAllBindless(U32(MaterialSet::kBindless));
+	cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler), args.m_sampler);
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
 #define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
-	cmdb->bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
-									&UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
+	cmdb.bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
+								   &UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
 #include <AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h>
 
 	// Misc
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32A32_Uint, 0);
-	cmdb->bindIndexBuffer(&UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, IndexType::kU16);
+	cmdb.setVertexAttribute(0, 0, Format::kR32G32B32A32_Uint, 0);
+	cmdb.bindIndexBuffer(&UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, IndexType::kU16);
+}
 
-	// Set a few things
-	Context ctx;
-	ctx.m_commandBuffer = cmdb;
+void RenderableDrawer::drawRange(const RenderableDrawerArguments& args, const RenderableQueueElement* begin, const RenderableQueueElement* end,
+								 CommandBuffer& cmdb)
+{
+	ANKI_ASSERT(begin && end && begin < end);
 
+	setState(args, cmdb);
+
+	Context ctx;
 	for(; begin != end; ++begin)
 	{
-		drawSingle(begin, ctx);
+		drawSingle(begin, ctx, cmdb);
 	}
 
 	// Flush the last drawcall
-	flushDrawcall(ctx);
+	flushDrawcall(ctx, cmdb);
 }
 
-void RenderableDrawer::flushDrawcall(Context& ctx)
+void RenderableDrawer::flushDrawcall(Context& ctx, CommandBuffer& cmdb)
 {
-	CommandBufferPtr cmdb = ctx.m_commandBuffer;
-
 	// Instance buffer
 	RebarAllocation token;
 	GpuSceneRenderablePacked* instances = static_cast<GpuSceneRenderablePacked*>(
@@ -99,25 +98,25 @@ void RenderableDrawer::flushDrawcall(Context& ctx)
 		instances[i] = packGpuSceneRenderable(renderable);
 	}
 
-	cmdb->bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, sizeof(GpuSceneRenderablePacked),
-						   VertexStepRate::kInstance);
+	cmdb.bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, sizeof(GpuSceneRenderablePacked),
+						  VertexStepRate::kInstance);
 
 	// Set state
 	const RenderableQueueElement& firstElement = *ctx.m_cachedRenderElements[0];
 
 	if(firstElement.m_program != ctx.m_lastBoundShaderProgram)
 	{
-		cmdb->bindShaderProgram(firstElement.m_program);
+		cmdb.bindShaderProgram(firstElement.m_program);
 		ctx.m_lastBoundShaderProgram = firstElement.m_program;
 	}
 
 	if(firstElement.m_indexed)
 	{
-		cmdb->drawIndexed(firstElement.m_primitiveTopology, firstElement.m_indexCount, ctx.m_cachedRenderElementCount, firstElement.m_firstIndex);
+		cmdb.drawIndexed(firstElement.m_primitiveTopology, firstElement.m_indexCount, ctx.m_cachedRenderElementCount, firstElement.m_firstIndex);
 	}
 	else
 	{
-		cmdb->draw(firstElement.m_primitiveTopology, firstElement.m_vertexCount, ctx.m_cachedRenderElementCount, firstElement.m_firstVertex);
+		cmdb.draw(firstElement.m_primitiveTopology, firstElement.m_vertexCount, ctx.m_cachedRenderElementCount, firstElement.m_firstVertex);
 	}
 
 	// Rendered something, reset the cached transforms
@@ -128,11 +127,11 @@ void RenderableDrawer::flushDrawcall(Context& ctx)
 	ctx.m_cachedRenderElementCount = 0;
 }
 
-void RenderableDrawer::drawSingle(const RenderableQueueElement* renderEl, Context& ctx)
+void RenderableDrawer::drawSingle(const RenderableQueueElement* renderEl, Context& ctx, CommandBuffer& cmdb)
 {
 	if(ctx.m_cachedRenderElementCount == kMaxInstanceCount)
 	{
-		flushDrawcall(ctx);
+		flushDrawcall(ctx, cmdb);
 	}
 
 	const Bool shouldFlush =
@@ -140,7 +139,7 @@ void RenderableDrawer::drawSingle(const RenderableQueueElement* renderEl, Contex
 
 	if(shouldFlush)
 	{
-		flushDrawcall(ctx);
+		flushDrawcall(ctx, cmdb);
 	}
 
 	// Cache the new one
@@ -148,4 +147,37 @@ void RenderableDrawer::drawSingle(const RenderableQueueElement* renderEl, Contex
 	++ctx.m_cachedRenderElementCount;
 }
 
+void RenderableDrawer::drawMdi(const RenderableDrawerArguments& args, CommandBuffer& cmdb)
+{
+	setState(args, cmdb);
+
+	cmdb.bindVertexBuffer(0, args.m_instaceRateRenderables, args.m_instaceRateRenderablesOffset, sizeof(GpuSceneRenderablePacked),
+						  VertexStepRate::kInstance);
+
+	U32 allUserCount = 0;
+	U32 bucketCount = 0;
+	RenderStateBucketContainer::getSingleton().iterateBuckets(args.m_renderingTechinuqe, [&](const RenderStateInfo& state, U32 userCount) {
+		if(userCount == 0)
+		{
+			++bucketCount;
+			return;
+		}
+
+		ANKI_ASSERT(state.m_indexedDrawcall && "TODO non-indexed");
+
+		ShaderProgramPtr prog = state.m_program;
+		cmdb.bindShaderProgram(prog.get());
+
+		const U32 maxDrawCount = userCount;
+		cmdb.drawIndexedIndirectCount(state.m_primitiveTopology, args.m_drawIndexedIndirectArgsBuffer,
+									  args.m_drawIndexedIndirectArgsBufferOffset + sizeof(DrawIndexedIndirectArgs) * allUserCount,
+									  args.m_mdiDrawCountsBuffer, args.m_mdiDrawCountsBufferOffset + sizeof(U32) * bucketCount, maxDrawCount);
+
+		++bucketCount;
+		allUserCount += userCount;
+	});
+
+	ANKI_ASSERT(bucketCount == RenderStateBucketContainer::getSingleton().getBucketCount(args.m_renderingTechinuqe));
+}
+
 } // end namespace anki

AnKi/Renderer/Drawer.h

@@ -29,6 +29,21 @@ public:
 	Mat4 m_previousViewProjectionMatrix;
 
 	Sampler* m_sampler;
+
+	// For MDI
+	RenderingTechnique m_renderingTechinuqe = RenderingTechnique::kCount;
+
+	Buffer* m_mdiDrawCountsBuffer = nullptr;
+	PtrSize m_mdiDrawCountsBufferOffset = 0;
+	PtrSize m_mdiDrawCountsBufferRange = 0;
+
+	Buffer* m_drawIndexedIndirectArgsBuffer = nullptr;
+	PtrSize m_drawIndexedIndirectArgsBufferOffset = 0;
+	PtrSize m_drawIndexedIndirectArgsBufferRange = 0;
+
+	Buffer* m_instaceRateRenderables = nullptr;
+	PtrSize m_instaceRateRenderablesOffset = 0;
+	PtrSize m_instaceRateRenderablesRange = 0;
 };
 
 /// It uses the render queue to batch and render.
@@ -42,14 +57,18 @@ public:
 	~RenderableDrawer();
 
 	void drawRange(const RenderableDrawerArguments& args, const RenderableQueueElement* begin, const RenderableQueueElement* end,
-				   CommandBufferPtr& cmdb);
+				   CommandBuffer& cmdb);
+
+	void drawMdi(const RenderableDrawerArguments& args, CommandBuffer& cmdb);
 
 private:
 	class Context;
 
-	void flushDrawcall(Context& ctx);
+	void setState(const RenderableDrawerArguments& args, CommandBuffer& cmdb);
+
+	void flushDrawcall(Context& ctx, CommandBuffer& cmdb);
 
-	void drawSingle(const RenderableQueueElement* renderEl, Context& ctx);
+	void drawSingle(const RenderableQueueElement* renderEl, Context& ctx, CommandBuffer& cmdb);
 };
 /// @}
 

AnKi/Renderer/FinalComposite.cpp

@@ -117,7 +117,7 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 
 void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const Bool dbgEnabled = ConfigSet::getSingleton().getRDbg();
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
@@ -127,28 +127,28 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 	// Bind program
 	if(hasDebugRt && optionalDebugProgram.isCreated())
 	{
-		cmdb->bindShaderProgram(optionalDebugProgram.get());
+		cmdb.bindShaderProgram(optionalDebugProgram.get());
 	}
 	else if(hasDebugRt)
 	{
-		cmdb->bindShaderProgram(m_defaultVisualizeRenderTargetGrProg.get());
+		cmdb.bindShaderProgram(m_defaultVisualizeRenderTargetGrProg.get());
 	}
 	else
 	{
-		cmdb->bindShaderProgram(m_grProgs[dbgEnabled].get());
+		cmdb.bindShaderProgram(m_grProgs[dbgEnabled].get());
 	}
 
 	// Bind stuff
 	if(!hasDebugRt)
 	{
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
-		cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getScale().getTonemappedRt());
 
 		rgraphCtx.bindColorTexture(0, 4, getRenderer().getBloom().getRt());
-		cmdb->bindTexture(0, 5, &m_lut->getTextureView());
+		cmdb.bindTexture(0, 5, &m_lut->getTextureView());
 		rgraphCtx.bindColorTexture(0, 6, getRenderer().getMotionVectors().getMotionVectorsRt());
 		rgraphCtx.bindTexture(0, 7, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
@@ -158,11 +158,11 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 		}
 
 		const UVec4 pc(0, 0, floatBitsToUint(ConfigSet::getSingleton().getRFilmGrainStrength()), getRenderer().getFrameCount() & kMaxU32);
-		cmdb->setPushConstants(&pc, sizeof(pc));
+		cmdb.setPushConstants(&pc, sizeof(pc));
 	}
 	else
 	{
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 		U32 count = 1;
 		for(const RenderTargetHandle& handle : dbgRts)
@@ -174,7 +174,7 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 		}
 	}
 
-	cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
+	cmdb.setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
 	drawQuad(cmdb);
 
 	// Draw UI

AnKi/Renderer/ForwardShading.cpp

@@ -21,7 +21,7 @@ namespace anki {
 
 void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const U32 threadId = rgraphCtx.m_currentSecondLevelCommandBufferIndex;
 	const U32 threadCount = rgraphCtx.m_secondLevelCommandBufferCount;
 	const U32 problemSize = ctx.m_renderQueue->m_forwardShadingRenderables.getSize();
@@ -30,12 +30,12 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 	if(start != end)
 	{
-		cmdb->setDepthWrite(false);
-		cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
+		cmdb.setDepthWrite(false);
+		cmdb.setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 
 		const U32 set = U32(MaterialSet::kGlobal);
-		cmdb->bindSampler(set, U32(MaterialBinding::kLinearClampSampler), getRenderer().getSamplers().m_trilinearClamp.get());
-		cmdb->bindSampler(set, U32(MaterialBinding::kShadowSampler), getRenderer().getSamplers().m_trilinearClampShadow.get());
+		cmdb.bindSampler(set, U32(MaterialBinding::kLinearClampSampler), getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(set, U32(MaterialBinding::kShadowSampler), getRenderer().getSamplers().m_trilinearClampShadow.get());
 
 		rgraphCtx.bindTexture(set, U32(MaterialBinding::kDepthRt), getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 		rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kLightVolume), getRenderer().getVolumetricLightingAccumulation().getRt());
@@ -60,8 +60,8 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 												 ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + end, cmdb);
 
 		// Restore state
-		cmdb->setDepthWrite(true);
-		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+		cmdb.setDepthWrite(true);
+		cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	}
 
 	if(threadId == threadCount - 1 && ctx.m_renderQueue->m_lensFlares.getSize())

AnKi/Renderer/GBuffer.cpp

@@ -88,7 +88,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 {
 	ANKI_TRACE_SCOPED_EVENT(RGBuffer);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const U32 threadId = rgraphCtx.m_currentSecondLevelCommandBufferIndex;
 	const U32 threadCount = rgraphCtx.m_secondLevelCommandBufferCount;
 
@@ -104,21 +104,21 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	}
 
 	// Set some state, leave the rest to default
-	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
+	cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
 	const I32 earlyZStart = max(I32(start), 0);
 	const I32 earlyZEnd = min(I32(end), I32(earlyZCount));
 	const I32 colorStart = max(I32(start) - I32(earlyZCount), 0);
 	const I32 colorEnd = I32(end) - I32(earlyZCount);
 
-	cmdb->setRasterizationOrder(RasterizationOrder::kRelaxed);
+	cmdb.setRasterizationOrder(RasterizationOrder::kRelaxed);
 
 	const Bool enableVrs =
 		GrManager::getSingleton().getDeviceCapabilities().m_vrs && ConfigSet::getSingleton().getRVrs() && ConfigSet::getSingleton().getRGBufferVrs();
 	if(enableVrs)
 	{
 		// Just set some low value, the attachment will take over
-		cmdb->setVrsRate(VrsRate::k1x1);
+		cmdb.setVrsRate(VrsRate::k1x1);
 	}
 
 	RenderableDrawerArguments args;
@@ -133,7 +133,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	{
 		for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
 		{
-			cmdb->setColorChannelWriteMask(i, ColorBit::kNone);
+			cmdb.setColorChannelWriteMask(i, ColorBit::kNone);
 		}
 
 		ANKI_ASSERT(earlyZStart < earlyZEnd && earlyZEnd <= I32(earlyZCount));
@@ -145,7 +145,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 		{
 			for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				cmdb->setColorChannelWriteMask(i, ColorBit::kAll);
+				cmdb.setColorChannelWriteMask(i, ColorBit::kAll);
 			}
 		}
 	}
@@ -153,7 +153,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	// Do the color writes
 	if(colorStart < colorEnd)
 	{
-		cmdb->setDepthCompareOperation(CompareOperation::kLessEqual);
+		cmdb.setDepthCompareOperation(CompareOperation::kLessEqual);
 
 		ANKI_ASSERT(colorStart < colorEnd && colorEnd <= I32(ctx.m_renderQueue->m_renderables.getSize()));
 		getRenderer().getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_renderables.getBegin() + colorStart,

AnKi/Renderer/GBufferPost.cpp

@@ -75,20 +75,20 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 void GBufferPost::run(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
-	cmdb->bindShaderProgram(m_grProg.get());
+	cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
+	cmdb.bindShaderProgram(m_grProg.get());
 
-	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
-	cmdb->setBlendFactors(1, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
+	cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
+	cmdb.setBlendFactors(1, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
 
 	// Bind all
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 	rgraphCtx.bindTexture(0, 1, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
+	cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
 	bindUniforms(cmdb, 0, 3, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 
@@ -96,14 +96,14 @@ void GBufferPost::run(RenderPassWorkContext& rgraphCtx)
 
 	bindStorage(cmdb, 0, 5, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindAllBindless(1);
+	cmdb.bindAllBindless(1);
 
 	// Draw
-	cmdb->draw(PrimitiveTopology::kTriangles, 3);
+	cmdb.draw(PrimitiveTopology::kTriangles, 3);
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
-	cmdb->setBlendFactors(1, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb.setBlendFactors(1, BlendFactor::kOne, BlendFactor::kZero);
 }
 
 } // end namespace anki

AnKi/Renderer/GenericCompute.cpp

@@ -26,8 +26,10 @@ void GenericCompute::populateRenderGraph(RenderingContext& ctx)
 	pass.newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute);
 }
 
-void GenericCompute::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
+void GenericCompute::run([[maybe_unused]] const RenderingContext& ctx, [[maybe_unused]] RenderPassWorkContext& rgraphCtx)
 {
+	ANKI_ASSERT(!"TODO");
+#if 0
 	ANKI_ASSERT(ctx.m_renderQueue->m_genericGpuComputeJobs.getSize() > 0);
 
 	GenericGpuComputeJobQueueElementContext elementCtx;
@@ -47,6 +49,7 @@ void GenericCompute::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 		ANKI_ASSERT(element.m_callback);
 		element.m_callback(elementCtx, element.m_userData);
 	}
+#endif
 }
 
 } // end namespace anki

AnKi/Renderer/GpuVisibility.cpp

@@ -59,22 +59,22 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 	pass.newBufferDependency(m_runCtx.m_mdiDrawCounts, bufferUsage);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rpass) {
-		CommandBufferPtr& cmdb = rpass.m_commandBuffer;
+		CommandBuffer& cmdb = *rpass.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg.get());
+		cmdb.bindShaderProgram(m_grProg.get());
 
-		cmdb->bindStorageBuffer(
+		cmdb.bindStorageBuffer(
 			0, 0, &GpuSceneBuffer::getSingleton().getBuffer(),
 			GpuSceneContiguousArrays::getSingleton().getArrayBase(GpuSceneContiguousArrayType::kRenderableBoundingVolumesGBuffer),
 			GpuSceneContiguousArrays::getSingleton().getElementCount(GpuSceneContiguousArrayType::kRenderableBoundingVolumesGBuffer)
 				* sizeof(GpuSceneRenderableAabb));
 
-		cmdb->bindStorageBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(),
-								GpuSceneContiguousArrays::getSingleton().getArrayBase(GpuSceneContiguousArrayType::kRenderables),
-								GpuSceneContiguousArrays::getSingleton().getElementCount(GpuSceneContiguousArrayType::kRenderables)
-									* sizeof(GpuSceneRenderable));
+		cmdb.bindStorageBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(),
+							   GpuSceneContiguousArrays::getSingleton().getArrayBase(GpuSceneContiguousArrayType::kRenderables),
+							   GpuSceneContiguousArrays::getSingleton().getElementCount(GpuSceneContiguousArrayType::kRenderables)
+								   * sizeof(GpuSceneRenderable));
 
-		cmdb->bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+		cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
 		rpass.bindColorTexture(0, 3, getRenderer().getHiZ().getHiZRt());
 
@@ -110,7 +110,7 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		unis.m_aabbCount = GpuSceneContiguousArrays::getSingleton().getElementCount(GpuSceneContiguousArrayType::kRenderableBoundingVolumesGBuffer);
-		cmdb->setPushConstants(&unis, sizeof(unis));
+		cmdb.setPushConstants(&unis, sizeof(unis));
 
 		dispatchPPCompute(cmdb, 64, 1, unis.m_aabbCount, 1);
 	});

AnKi/Renderer/HiZ.cpp

@@ -74,15 +74,15 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(m_runCtx.m_hiZRt, TextureUsageBit::kImageComputeWrite, firstMipSubresource);
 
 		pass.setWork([this](RenderPassWorkContext& rctx) {
-			CommandBufferPtr& cmdb = rctx.m_commandBuffer;
+			CommandBuffer& cmdb = *rctx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_clearHiZ.m_grProg.get());
+			cmdb.bindShaderProgram(m_clearHiZ.m_grProg.get());
 
 			TextureSubresourceInfo firstMipSubresource;
 			rctx.bindImage(0, 0, m_runCtx.m_hiZRt, firstMipSubresource);
 
 			UVec4 clearColor(0u);
-			cmdb->setPushConstants(&clearColor, sizeof(clearColor));
+			cmdb.setPushConstants(&clearColor, sizeof(clearColor));
 
 			dispatchPPCompute(cmdb, 8, 8, 1, m_hiZRtDescr.m_width, m_hiZRtDescr.m_height, 1);
 		});
@@ -95,15 +95,15 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(getRenderer().getGBuffer().getPreviousFrameDepthRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rctx) {
-			CommandBufferPtr& cmdb = rctx.m_commandBuffer;
+			CommandBuffer& cmdb = *rctx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_reproj.m_grProg.get());
+			cmdb.bindShaderProgram(m_reproj.m_grProg.get());
 
 			rctx.bindTexture(0, 0, getRenderer().getGBuffer().getPreviousFrameDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 			TextureSubresourceInfo firstMipSubresource;
 			rctx.bindImage(0, 1, m_runCtx.m_hiZRt, firstMipSubresource);
 
-			cmdb->setPushConstants(&ctx.m_matrices.m_reprojection, sizeof(Mat4));
+			cmdb.setPushConstants(&ctx.m_matrices.m_reprojection, sizeof(Mat4));
 
 			dispatchPPCompute(cmdb, 8, 8, 1, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(), 1);
 		});
@@ -123,7 +123,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 			TextureSubresourceInfo firstMipSubresource;
 			const U32 mipsToCompute = m_hiZRtDescr.m_mipmapCount - 1;
@@ -133,14 +133,14 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 			{
 				m_mipmapping.m_counterBufferZeroed = true;
 
-				cmdb->fillBuffer(m_mipmapping.m_counterBuffer.get(), 0, kMaxPtrSize, 0);
+				cmdb.fillBuffer(m_mipmapping.m_counterBuffer.get(), 0, kMaxPtrSize, 0);
 
 				const BufferBarrierInfo barrier = {m_mipmapping.m_counterBuffer.get(), BufferUsageBit::kTransferDestination,
 												   BufferUsageBit::kStorageComputeWrite, 0, kMaxPtrSize};
-				cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
+				cmdb.setPipelineBarrier({}, {&barrier, 1}, {});
 			}
 
-			cmdb->bindShaderProgram(m_mipmapping.m_grProg.get());
+			cmdb.bindShaderProgram(m_mipmapping.m_grProg.get());
 
 			varAU2(dispatchThreadGroupCountXY);
 			varAU2(workGroupOffset); // needed if Left and Top are not 0,0
@@ -159,7 +159,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 			pc.m_threadGroupCount = numWorkGroupsAndMips[0];
 			pc.m_mipmapCount = numWorkGroupsAndMips[1];
 
-			cmdb->setPushConstants(&pc, sizeof(pc));
+			cmdb.setPushConstants(&pc, sizeof(pc));
 
 			constexpr U32 maxMipsSpdCanProduce = 12;
 			for(U32 mip = 0; mip < maxMipsSpdCanProduce; ++mip)
@@ -191,11 +191,11 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 				rgraphCtx.bindImage(0, 1, m_runCtx.m_hiZRt, subresource);
 			}
 
-			cmdb->bindStorageBuffer(0, 2, m_mipmapping.m_counterBuffer.get(), 0, kMaxPtrSize);
+			cmdb.bindStorageBuffer(0, 2, m_mipmapping.m_counterBuffer.get(), 0, kMaxPtrSize);
 
 			rgraphCtx.bindTexture(0, 3, m_runCtx.m_hiZRt, firstMipSubresource);
 
-			cmdb->dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
+			cmdb.dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
 		});
 	}
 }

AnKi/Renderer/IndirectDiffuse.cpp

@@ -167,12 +167,12 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 viewport = getRenderer().getInternalResolution() / 2u;
 
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_vrs.m_grProg.get());
+			cmdb.bindShaderProgram(m_vrs.m_grProg.get());
 
 			rgraphCtx.bindTexture(0, 0, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
+			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_sriRt);
 
 			class
@@ -185,7 +185,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			pc.m_v4 = Vec4(1.0f / Vec2(viewport), ConfigSet::getSingleton().getRIndirectDiffuseVrsDistanceThreshold(), 0.0f);
 			pc.m_invertedProjectionJitter = ctx.m_matrices.m_invertedProjectionJitter;
 
-			cmdb->setPushConstants(&pc, sizeof(pc));
+			cmdb.setPushConstants(&pc, sizeof(pc));
 
 			dispatchPPCompute(cmdb, m_vrs.m_sriTexelDimension, m_vrs.m_sriTexelDimension, viewport.x(), viewport.y());
 		});
@@ -250,14 +250,14 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[kRead], readUsage);
 
 		prpass->setWork([this, &ctx, enableVrs](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-			cmdb->bindShaderProgram(m_main.m_grProg.get());
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+			cmdb.bindShaderProgram(m_main.m_grProg.get());
 
 			bindUniforms(cmdb, 0, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 			getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 1, ClusteredObjectType::kGlobalIlluminationProbe);
 			bindStorage(cmdb, 0, 2, getRenderer().getClusterBinning().getClustersRebarToken());
 
-			cmdb->bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp.get());
+			cmdb.bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 4, getRenderer().getGBuffer().getColorRt(2));
 
 			TextureSubresourceInfo hizSubresource;
@@ -273,7 +273,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 				rgraphCtx.bindImage(0, 10, m_runCtx.m_mainRtHandles[kWrite]);
 			}
 
-			cmdb->bindAllBindless(1);
+			cmdb.bindAllBindless(1);
 
 			// Bind uniforms
 			IndirectDiffuseUniforms unis;
@@ -286,7 +286,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			unis.m_sampleCountf = F32(unis.m_sampleCount);
 			unis.m_ssaoBias = ConfigSet::getSingleton().getRIndirectDiffuseSsaoBias();
 			unis.m_ssaoStrength = ConfigSet::getSingleton().getRIndirectDiffuseSsaoStrength();
-			cmdb->setPushConstants(&unis, sizeof(unis));
+			cmdb.setPushConstants(&unis, sizeof(unis));
 
 			if(ConfigSet::getSingleton().getRPreferCompute())
 			{
@@ -294,14 +294,14 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				cmdb->setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+				cmdb.setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
 
 				if(enableVrs)
 				{
-					cmdb->setVrsRate(VrsRate::k1x1);
+					cmdb.setVrsRate(VrsRate::k1x1);
 				}
 
-				cmdb->draw(PrimitiveTopology::kTriangles, 3);
+				cmdb.draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}
@@ -338,10 +338,10 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[!readIdx], writeUsage);
 
 		prpass->setWork([this, &ctx, dir, readIdx](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-			cmdb->bindShaderProgram(m_denoise.m_grProgs[dir].get());
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+			cmdb.bindShaderProgram(m_denoise.m_grProgs[dir].get());
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_mainRtHandles[readIdx]);
 			TextureSubresourceInfo hizSubresource;
 			hizSubresource.m_mipmapCount = 1;
@@ -359,7 +359,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			unis.m_sampleCountDiv2 = F32(ConfigSet::getSingleton().getRIndirectDiffuseDenoiseSampleCount());
 			unis.m_sampleCountDiv2 = max(1.0f, std::round(unis.m_sampleCountDiv2 / 2.0f));
 
-			cmdb->setPushConstants(&unis, sizeof(unis));
+			cmdb.setPushConstants(&unis, sizeof(unis));
 
 			if(ConfigSet::getSingleton().getRPreferCompute())
 			{
@@ -367,9 +367,9 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				cmdb->setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
+				cmdb.setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
 
-				cmdb->draw(PrimitiveTopology::kTriangles, 3);
+				cmdb.draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -328,7 +328,7 @@ void IndirectDiffuseProbes::runGBufferInThread(RenderPassWorkContext& rgraphCtx,
 	ANKI_ASSERT(giCtx.m_probeToUpdateThisFrame);
 	ANKI_TRACE_SCOPED_EVENT(RIndirectDiffuse);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const GlobalIlluminationProbeQueueElementForRefresh& probe = *giCtx.m_probeToUpdateThisFrame;
 
 	I32 start, end;
@@ -348,8 +348,8 @@ void IndirectDiffuseProbes::runGBufferInThread(RenderPassWorkContext& rgraphCtx,
 		if(localStart < localEnd)
 		{
 			const U32 viewportX = faceIdx * m_tileSize;
-			cmdb->setViewport(viewportX, 0, m_tileSize, m_tileSize);
-			cmdb->setScissor(viewportX, 0, m_tileSize, m_tileSize);
+			cmdb.setViewport(viewportX, 0, m_tileSize, m_tileSize);
+			cmdb.setScissor(viewportX, 0, m_tileSize, m_tileSize);
 
 			const RenderQueue& rqueue = *probe.m_renderQueues[faceIdx];
 
@@ -387,8 +387,8 @@ void IndirectDiffuseProbes::runShadowmappingInThread(RenderPassWorkContext& rgra
 	start = I32(startu);
 	end = I32(endu);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-	cmdb->setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+	cmdb.setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
 
 	I32 drawcallCount = 0;
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
@@ -406,8 +406,8 @@ void IndirectDiffuseProbes::runShadowmappingInThread(RenderPassWorkContext& rgra
 		if(localStart < localEnd)
 		{
 			const U32 rez = m_shadowMapping.m_rtDescr.m_height;
-			cmdb->setViewport(rez * faceIdx, 0, rez, rez);
-			cmdb->setScissor(rez * faceIdx, 0, rez, rez);
+			cmdb.setViewport(rez * faceIdx, 0, rez, rez);
+			cmdb.setScissor(rez * faceIdx, 0, rez, rez);
 
 			ANKI_ASSERT(localStart >= 0 && localEnd <= faceDrawcallCount);
 
@@ -433,7 +433,7 @@ void IndirectDiffuseProbes::runLightShading(RenderPassWorkContext& rgraphCtx, In
 	ANKI_ASSERT(giCtx.m_probeToUpdateThisFrame);
 	const GlobalIlluminationProbeQueueElementForRefresh& probe = *giCtx.m_probeToUpdateThisFrame;
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
 	{
@@ -441,8 +441,8 @@ void IndirectDiffuseProbes::runLightShading(RenderPassWorkContext& rgraphCtx, In
 		const RenderQueue& rqueue = *probe.m_renderQueues[faceIdx];
 
 		const U32 rez = m_tileSize;
-		cmdb->setScissor(rez * faceIdx, 0, rez, rez);
-		cmdb->setViewport(rez * faceIdx, 0, rez, rez);
+		cmdb.setScissor(rez * faceIdx, 0, rez, rez);
+		cmdb.setViewport(rez * faceIdx, 0, rez, rez);
 
 		// Draw light shading
 		TraditionalDeferredLightShadingDrawInfo dsInfo;
@@ -459,7 +459,7 @@ void IndirectDiffuseProbes::runLightShading(RenderPassWorkContext& rgraphCtx, In
 		dsInfo.m_directionalLight = (rqueue.m_directionalLight.isEnabled()) ? &rqueue.m_directionalLight : nullptr;
 		dsInfo.m_pointLights = rqueue.m_pointLights;
 		dsInfo.m_spotLights = rqueue.m_spotLights;
-		dsInfo.m_commandBuffer = cmdb;
+		dsInfo.m_commandBuffer = &cmdb;
 		dsInfo.m_gbufferRenderTargets[0] = giCtx.m_gbufferColorRts[0];
 		dsInfo.m_gbufferRenderTargets[1] = giCtx.m_gbufferColorRts[1];
 		dsInfo.m_gbufferRenderTargets[2] = giCtx.m_gbufferColorRts[2];
@@ -479,14 +479,14 @@ void IndirectDiffuseProbes::runIrradiance(RenderPassWorkContext& rgraphCtx, Inte
 {
 	ANKI_TRACE_SCOPED_EVENT(RIndirectDiffuse);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	ANKI_ASSERT(giCtx.m_probeToUpdateThisFrame);
 	const GlobalIlluminationProbeQueueElementForRefresh& probe = *giCtx.m_probeToUpdateThisFrame;
 
-	cmdb->bindShaderProgram(m_irradiance.m_grProg.get());
+	cmdb.bindShaderProgram(m_irradiance.m_grProg.get());
 
 	// Bind resources
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, giCtx.m_lightShadingRt);
 
 	for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
@@ -505,10 +505,10 @@ void IndirectDiffuseProbes::runIrradiance(RenderPassWorkContext& rgraphCtx, Inte
 
 	unis.m_volumeTexel = IVec3(probe.m_cellToRefresh.x(), probe.m_cellToRefresh.y(), probe.m_cellToRefresh.z());
 	unis.m_nextTexelOffsetInU = probe.m_cellCounts.x();
-	cmdb->setPushConstants(&unis, sizeof(unis));
+	cmdb.setPushConstants(&unis, sizeof(unis));
 
 	// Dispatch
-	cmdb->dispatchCompute(1, 1, 1);
+	cmdb.dispatchCompute(1, 1, 1);
 }
 
 } // end namespace anki

AnKi/Renderer/IndirectSpecular.cpp

@@ -161,8 +161,8 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 
 void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-	cmdb->bindShaderProgram(m_grProg.get());
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+	cmdb.bindShaderProgram(m_grProg.get());
 
 	const U32 depthLod = min(ConfigSet::getSingleton().getRSsrDepthLod(), getRenderer().getDepthDownscale().getMipmapCount() - 1);
 
@@ -182,7 +182,7 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	unis->m_roughnessCutoff = ConfigSet::getSingleton().getRSsrRoughnessCutoff();
 
 	// Bind all
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
 	rgraphCtx.bindColorTexture(0, 2, getRenderer().getGBuffer().getColorRt(1));
 	rgraphCtx.bindColorTexture(0, 3, getRenderer().getGBuffer().getColorRt(2));
@@ -197,14 +197,14 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	rgraphCtx.bindColorTexture(0, 7, getRenderer().getMotionVectors().getMotionVectorsRt());
 	rgraphCtx.bindColorTexture(0, 8, getRenderer().getMotionVectors().getHistoryLengthRt());
 
-	cmdb->bindSampler(0, 9, getRenderer().getSamplers().m_trilinearRepeat.get());
-	cmdb->bindTexture(0, 10, &m_noiseImage->getTextureView());
+	cmdb.bindSampler(0, 9, getRenderer().getSamplers().m_trilinearRepeat.get());
+	cmdb.bindTexture(0, 10, &m_noiseImage->getTextureView());
 
 	bindUniforms(cmdb, 0, 11, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 12, ClusteredObjectType::kReflectionProbe);
 	bindStorage(cmdb, 0, 13, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindAllBindless(1);
+	cmdb.bindAllBindless(1);
 
 	if(ConfigSet::getSingleton().getRPreferCompute())
 	{
@@ -214,9 +214,9 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
+		cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
 
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/LensFlare.cpp

@@ -72,13 +72,13 @@ Error LensFlare::initOcclusion()
 
 void LensFlare::updateIndirectInfo(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	U32 count = min<U32>(ctx.m_renderQueue->m_lensFlares.getSize(), m_maxFlares);
 	ANKI_ASSERT(count > 0);
 
-	cmdb->bindShaderProgram(m_updateIndirectBuffGrProg.get());
+	cmdb.bindShaderProgram(m_updateIndirectBuffGrProg.get());
 
-	cmdb->setPushConstants(&ctx.m_matrices.m_viewProjectionJitter, sizeof(ctx.m_matrices.m_viewProjectionJitter));
+	cmdb.setPushConstants(&ctx.m_matrices.m_viewProjectionJitter, sizeof(ctx.m_matrices.m_viewProjectionJitter));
 
 	// Write flare info
 	Vec4* flarePositions = allocateAndBindStorage<Vec4*>(count * sizeof(Vec4), cmdb, 0, 0);
@@ -90,9 +90,9 @@ void LensFlare::updateIndirectInfo(const RenderingContext& ctx, RenderPassWorkCo
 
 	rgraphCtx.bindStorageBuffer(0, 1, m_runCtx.m_indirectBuffHandle);
 	// Bind neareset because you don't need high quality
-	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getHiZRt(), kHiZQuarterSurface);
-	cmdb->dispatchCompute(count, 1, 1);
+	cmdb.dispatchCompute(count, 1, 1);
 }
 
 void LensFlare::populateRenderGraph(RenderingContext& ctx)
@@ -120,7 +120,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 	}
 }
 
-void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmdb)
+void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBuffer& cmdb)
 {
 	if(ctx.m_renderQueue->m_lensFlares.getSize() == 0)
 	{
@@ -129,9 +129,9 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 
 	const U32 count = min<U32>(ctx.m_renderQueue->m_lensFlares.getSize(), m_maxFlares);
 
-	cmdb->bindShaderProgram(m_realGrProg.get());
-	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
-	cmdb->setDepthWrite(false);
+	cmdb.bindShaderProgram(m_realGrProg.get());
+	cmdb.setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
+	cmdb.setDepthWrite(false);
 
 	for(U32 i = 0; i < count; ++i)
 	{
@@ -168,15 +168,15 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 
 		// Render
 		ANKI_ASSERT(flareEl.m_textureView);
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearRepeat.get());
-		cmdb->bindTexture(0, 2, flareEl.m_textureView);
+		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearRepeat.get());
+		cmdb.bindTexture(0, 2, flareEl.m_textureView);
 
-		cmdb->drawIndirect(PrimitiveTopology::kTriangleStrip, 1, i * sizeof(DrawIndirectArgs), m_indirectBuff.get());
+		cmdb.drawIndirect(PrimitiveTopology::kTriangleStrip, 1, i * sizeof(DrawIndirectArgs), m_indirectBuff.get());
 	}
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
-	cmdb->setDepthWrite(true);
+	cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb.setDepthWrite(true);
 }
 
 } // end namespace anki

AnKi/Renderer/LensFlare.h

@@ -20,7 +20,7 @@ class LensFlare : public RendererObject
 public:
 	Error init();
 
-	void runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmdb);
+	void runDrawFlares(const RenderingContext& ctx, CommandBuffer& cmdb);
 
 	void populateRenderGraph(RenderingContext& ctx);
 

AnKi/Renderer/LightShading.cpp

@@ -138,22 +138,22 @@ Error LightShading::initApplyIndirect()
 
 void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
+	cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
 	const Bool enableVrs = GrManager::getSingleton().getDeviceCapabilities().m_vrs && ConfigSet::getSingleton().getRVrs();
 	if(enableVrs)
 	{
 		// Just set some low value, the attachment will take over
-		cmdb->setVrsRate(VrsRate::k1x1);
+		cmdb.setVrsRate(VrsRate::k1x1);
 	}
 
 	// Do light shading first
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
-		cmdb->bindShaderProgram(m_lightShading.m_grProg[getRenderer().getRtShadowsEnabled()].get());
-		cmdb->setDepthWrite(false);
+		cmdb.bindShaderProgram(m_lightShading.m_grProg[getRenderer().getRtShadowsEnabled()].get());
+		cmdb.setDepthWrite(false);
 
 		// Bind all
 		bindUniforms(cmdb, 0, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
@@ -164,8 +164,8 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 
 		bindStorage(cmdb, 0, 4, getRenderer().getClusterBinning().getClustersRebarToken());
 
-		cmdb->bindSampler(0, 5, getRenderer().getSamplers().m_nearestNearestClamp.get());
-		cmdb->bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 7, getRenderer().getGBuffer().getColorRt(0));
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getGBuffer().getColorRt(1));
 		rgraphCtx.bindColorTexture(0, 9, getRenderer().getGBuffer().getColorRt(2));
@@ -187,11 +187,11 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 	// Apply indirect
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
-		cmdb->setDepthWrite(false);
-		cmdb->bindShaderProgram(m_applyIndirect.m_grProg.get());
+		cmdb.setDepthWrite(false);
+		cmdb.bindShaderProgram(m_applyIndirect.m_grProg.get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 2, getRenderer().getIndirectDiffuse().getRt());
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getIndirectSpecular().getRt());
 		rgraphCtx.bindColorTexture(0, 4, getRenderer().getDepthDownscale().getHiZRt());
@@ -199,38 +199,38 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		rgraphCtx.bindColorTexture(0, 6, getRenderer().getGBuffer().getColorRt(0));
 		rgraphCtx.bindColorTexture(0, 7, getRenderer().getGBuffer().getColorRt(1));
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getGBuffer().getColorRt(2));
-		cmdb->bindTexture(0, 9, &getRenderer().getProbeReflections().getIntegrationLut());
+		cmdb.bindTexture(0, 9, &getRenderer().getProbeReflections().getIntegrationLut());
 
 		bindUniforms(cmdb, 0, 10, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 
 		const Vec4 pc(ctx.m_renderQueue->m_cameraNear, ctx.m_renderQueue->m_cameraFar, 0.0f, 0.0f);
-		cmdb->setPushConstants(&pc, sizeof(pc));
+		cmdb.setPushConstants(&pc, sizeof(pc));
 
-		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
+		cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
 
 		drawQuad(cmdb);
 
 		// Restore state
-		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+		cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	}
 
 	// Skybox
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
-		cmdb->setDepthCompareOperation(CompareOperation::kEqual);
+		cmdb.setDepthCompareOperation(CompareOperation::kEqual);
 
 		const Bool isSolidColor = ctx.m_renderQueue->m_skybox.m_skyboxTexture == nullptr;
 
 		if(isSolidColor)
 		{
-			cmdb->bindShaderProgram(m_skybox.m_grProgs[0].get());
+			cmdb.bindShaderProgram(m_skybox.m_grProgs[0].get());
 
 			const Vec4 color(ctx.m_renderQueue->m_skybox.m_solidColor, 0.0);
-			cmdb->setPushConstants(&color, sizeof(color));
+			cmdb.setPushConstants(&color, sizeof(color));
 		}
 		else
 		{
-			cmdb->bindShaderProgram(m_skybox.m_grProgs[1].get());
+			cmdb.bindShaderProgram(m_skybox.m_grProgs[1].get());
 
 			class
 			{
@@ -243,26 +243,26 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 			pc.m_invertedViewProjectionJitter = ctx.m_matrices.m_invertedViewProjectionJitter;
 			pc.m_cameraPos = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
 
-			cmdb->setPushConstants(&pc, sizeof(pc));
+			cmdb.setPushConstants(&pc, sizeof(pc));
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias.get());
-			cmdb->bindTexture(0, 1, ctx.m_renderQueue->m_skybox.m_skyboxTexture);
+			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias.get());
+			cmdb.bindTexture(0, 1, ctx.m_renderQueue->m_skybox.m_skyboxTexture);
 		}
 
 		drawQuad(cmdb);
 
 		// Restore state
-		cmdb->setDepthCompareOperation(CompareOperation::kLess);
+		cmdb.setDepthCompareOperation(CompareOperation::kLess);
 	}
 
 	// Do the fog apply
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == rgraphCtx.m_secondLevelCommandBufferCount - 1u)
 	{
-		cmdb->bindShaderProgram(m_applyFog.m_grProg.get());
+		cmdb.bindShaderProgram(m_applyFog.m_grProg.get());
 
 		// Bind all
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
 		rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getVolumetricFog().getRt());
@@ -277,21 +277,21 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		regs.m_near = ctx.m_renderQueue->m_cameraNear;
 		regs.m_far = ctx.m_renderQueue->m_cameraFar;
 
-		cmdb->setPushConstants(&regs, sizeof(regs));
+		cmdb.setPushConstants(&regs, sizeof(regs));
 
 		// finalPixelColor = pixelWithoutFog * transmitance + inScattering (see the shader)
-		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha);
+		cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha);
 
 		drawQuad(cmdb);
 
 		// Reset state
-		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+		cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
 	}
 
 	// Forward shading last
 	if(enableVrs)
 	{
-		cmdb->setVrsRate(VrsRate::k2x2);
+		cmdb.setVrsRate(VrsRate::k2x2);
 	}
 
 	getRenderer().getForwardShading().run(ctx, rgraphCtx);
@@ -299,7 +299,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 	if(enableVrs)
 	{
 		// Restore
-		cmdb->setVrsRate(VrsRate::k1x1);
+		cmdb.setVrsRate(VrsRate::k1x1);
 	}
 }
 

AnKi/Renderer/MainRenderer.cpp

@@ -115,14 +115,14 @@ Error MainRenderer::render(RenderQueue& rqueue, Texture* presentTex)
 
 		pass.setFramebufferInfo(m_fbDescr, {presentRt});
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-			cmdb->setViewport(0, 0, m_swapchainResolution.x(), m_swapchainResolution.y());
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+			cmdb.setViewport(0, 0, m_swapchainResolution.x(), m_swapchainResolution.y());
 
-			cmdb->bindShaderProgram(m_blitGrProg.get());
-			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp.get());
+			cmdb.bindShaderProgram(m_blitGrProg.get());
+			cmdb.bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_ctx->m_outRenderTarget);
 
-			cmdb->draw(PrimitiveTopology::kTriangles, 3);
+			cmdb.draw(PrimitiveTopology::kTriangles, 3);
 		});
 
 		pass.newTextureDependency(presentRt, TextureUsageBit::kFramebufferWrite);

AnKi/Renderer/MotionVectors.cpp

@@ -122,11 +122,11 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 
 void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg.get());
+	cmdb.bindShaderProgram(m_grProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindTexture(0, 1, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getPreviousFrameDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	rgraphCtx.bindColorTexture(0, 3, getRenderer().getGBuffer().getColorRt(3));
@@ -157,9 +157,9 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
+		cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/PackVisibleClusteredObjects.cpp

@@ -54,7 +54,7 @@ Error PackVisibleClusteredObjects::init()
 }
 
 template<typename TClustererType, ClusteredObjectType kType, typename TRenderQueueElement>
-void PackVisibleClusteredObjects::dispatchType(WeakArray<TRenderQueueElement> array, const RenderQueue& rqueue, CommandBufferPtr& cmdb)
+void PackVisibleClusteredObjects::dispatchType(WeakArray<TRenderQueueElement> array, const RenderQueue& rqueue, CommandBuffer& cmdb)
 {
 	if(array.getSize() == 0)
 	{
@@ -110,22 +110,22 @@ void PackVisibleClusteredObjects::dispatchType(WeakArray<TRenderQueueElement> ar
 		}
 	}
 
-	cmdb->bindStorageBuffer(0, 0, &GpuSceneBuffer::getSingleton().getBuffer(), rqueue.m_clustererObjectsArrayOffsets[kType],
-							rqueue.m_clustererObjectsArrayRanges[kType]);
+	cmdb.bindStorageBuffer(0, 0, &GpuSceneBuffer::getSingleton().getBuffer(), rqueue.m_clustererObjectsArrayOffsets[kType],
+						   rqueue.m_clustererObjectsArrayRanges[kType]);
 
-	cmdb->bindStorageBuffer(0, 1, m_allClustererObjects.get(), m_structureBufferOffsets[kType], array.getSize() * sizeof(TClustererType));
+	cmdb.bindStorageBuffer(0, 1, m_allClustererObjects.get(), m_structureBufferOffsets[kType], array.getSize() * sizeof(TClustererType));
 
-	cmdb->bindStorageBuffer(0, 2, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, token.m_range);
+	cmdb.bindStorageBuffer(0, 2, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, token.m_range);
 
 	if constexpr(std::is_same_v<TClustererType, PointLight> || std::is_same_v<TClustererType, SpotLight>)
 	{
-		cmdb->bindStorageBuffer(0, 3, &RebarTransientMemoryPool::getSingleton().getBuffer(), extrasToken.m_offset, extrasToken.m_range);
+		cmdb.bindStorageBuffer(0, 3, &RebarTransientMemoryPool::getSingleton().getBuffer(), extrasToken.m_offset, extrasToken.m_range);
 	}
 
-	cmdb->bindShaderProgram(m_grProgs[kType].get());
+	cmdb.bindShaderProgram(m_grProgs[kType].get());
 
 	const UVec4 pc(array.getSize());
-	cmdb->setPushConstants(&pc, sizeof(pc));
+	cmdb.setPushConstants(&pc, sizeof(pc));
 
 	dispatchPPCompute(cmdb, m_threadGroupSize, 1, 1, array.getSize(), 1, 1);
 }
@@ -143,7 +143,7 @@ void PackVisibleClusteredObjects::populateRenderGraph(RenderingContext& ctx)
 
 	pass.setWork([&ctx, this](RenderPassWorkContext& rgraphCtx) {
 		const RenderQueue& rqueue = *ctx.m_renderQueue;
-		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 		dispatchType<PointLight, ClusteredObjectType::kPointLight>(rqueue.m_pointLights, rqueue, cmdb);
 		dispatchType<SpotLight, ClusteredObjectType::kSpotLight>(rqueue.m_spotLights, rqueue, cmdb);

AnKi/Renderer/PackVisibleClusteredObjects.h

@@ -26,10 +26,10 @@ public:
 		return m_allClustererObjectsHandle;
 	}
 
-	void bindClusteredObjectBuffer(CommandBufferPtr& cmdb, U32 set, U32 binding, ClusteredObjectType type) const
+	void bindClusteredObjectBuffer(CommandBuffer& cmdb, U32 set, U32 binding, ClusteredObjectType type) const
 	{
-		cmdb->bindStorageBuffer(set, binding, m_allClustererObjects.get(), m_structureBufferOffsets[type],
-								kClusteredObjectSizes[type] * kMaxVisibleClusteredObjects[type]);
+		cmdb.bindStorageBuffer(set, binding, m_allClustererObjects.get(), m_structureBufferOffsets[type],
+							   kClusteredObjectSizes[type] * kMaxVisibleClusteredObjects[type]);
 	}
 
 private:
@@ -44,7 +44,7 @@ private:
 	U32 m_threadGroupSize = 0;
 
 	template<typename TClustererType, ClusteredObjectType kType, typename TRenderQueueElement>
-	void dispatchType(WeakArray<TRenderQueueElement> array, const RenderQueue& rqueue, CommandBufferPtr& cmdb);
+	void dispatchType(WeakArray<TRenderQueueElement> array, const RenderQueue& rqueue, CommandBuffer& cmdb);
 };
 /// @}
 

AnKi/Renderer/ProbeReflections.cpp

@@ -179,7 +179,7 @@ void ProbeReflections::runGBuffer(RenderPassWorkContext& rgraphCtx)
 	ANKI_ASSERT(m_ctx.m_probe);
 	ANKI_TRACE_SCOPED_EVENT(RCubeRefl);
 	const ReflectionProbeQueueElementForRefresh& probe = *m_ctx.m_probe;
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	I32 start, end;
 	U32 startu, endu;
@@ -198,8 +198,8 @@ void ProbeReflections::runGBuffer(RenderPassWorkContext& rgraphCtx)
 		if(localStart < localEnd)
 		{
 			const U32 viewportX = faceIdx * m_gbuffer.m_tileSize;
-			cmdb->setViewport(viewportX, 0, m_gbuffer.m_tileSize, m_gbuffer.m_tileSize);
-			cmdb->setScissor(viewportX, 0, m_gbuffer.m_tileSize, m_gbuffer.m_tileSize);
+			cmdb.setViewport(viewportX, 0, m_gbuffer.m_tileSize, m_gbuffer.m_tileSize);
+			cmdb.setScissor(viewportX, 0, m_gbuffer.m_tileSize, m_gbuffer.m_tileSize);
 
 			const RenderQueue& rqueue = *probe.m_renderQueues[faceIdx];
 			ANKI_ASSERT(localStart >= 0 && localEnd <= faceDrawcallCount);
@@ -217,7 +217,7 @@ void ProbeReflections::runGBuffer(RenderPassWorkContext& rgraphCtx)
 	}
 
 	// Restore state
-	cmdb->setScissor(0, 0, kMaxU32, kMaxU32);
+	cmdb.setScissor(0, 0, kMaxU32, kMaxU32);
 }
 
 void ProbeReflections::runLightShading(U32 faceIdx, const RenderingContext& rctx, RenderPassWorkContext& rgraphCtx)
@@ -225,7 +225,7 @@ void ProbeReflections::runLightShading(U32 faceIdx, const RenderingContext& rctx
 	ANKI_ASSERT(faceIdx <= 6);
 	ANKI_TRACE_SCOPED_EVENT(RCubeRefl);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	ANKI_ASSERT(m_ctx.m_probe);
 	const ReflectionProbeQueueElementForRefresh& probe = *m_ctx.m_probe;
@@ -246,7 +246,7 @@ void ProbeReflections::runLightShading(U32 faceIdx, const RenderingContext& rctx
 	dsInfo.m_directionalLight = (hasDirLight) ? &probe.m_renderQueues[faceIdx]->m_directionalLight : nullptr;
 	dsInfo.m_pointLights = rqueue.m_pointLights;
 	dsInfo.m_spotLights = rqueue.m_spotLights;
-	dsInfo.m_commandBuffer = cmdb;
+	dsInfo.m_commandBuffer = &cmdb;
 	dsInfo.m_gbufferRenderTargets[0] = m_ctx.m_gbufferColorRts[0];
 	dsInfo.m_gbufferRenderTargets[1] = m_ctx.m_gbufferColorRts[1];
 	dsInfo.m_gbufferRenderTargets[2] = m_ctx.m_gbufferColorRts[2];
@@ -282,39 +282,39 @@ void ProbeReflections::runIrradiance(RenderPassWorkContext& rgraphCtx)
 {
 	ANKI_TRACE_SCOPED_EVENT(RCubeRefl);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_irradiance.m_grProg.get());
+	cmdb.bindShaderProgram(m_irradiance.m_grProg.get());
 
 	// Bind stuff
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 	TextureSubresourceInfo subresource;
 	subresource.m_faceCount = 6;
 	rgraphCtx.bindTexture(0, 1, m_ctx.m_lightShadingRt, subresource);
 
-	cmdb->bindStorageBuffer(0, 3, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
+	cmdb.bindStorageBuffer(0, 3, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
 
 	// Draw
-	cmdb->dispatchCompute(1, 1, 1);
+	cmdb.dispatchCompute(1, 1, 1);
 }
 
 void ProbeReflections::runIrradianceToRefl(RenderPassWorkContext& rgraphCtx)
 {
 	ANKI_TRACE_SCOPED_EVENT(RCubeRefl);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_irradianceToRefl.m_grProg.get());
+	cmdb.bindShaderProgram(m_irradianceToRefl.m_grProg.get());
 
 	// Bind resources
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[0], 0);
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[1], 1);
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[2], 2);
 
-	cmdb->bindStorageBuffer(0, 2, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
+	cmdb.bindStorageBuffer(0, 2, m_irradiance.m_diceValuesBuff.get(), 0, m_irradiance.m_diceValuesBuff->getSize());
 
 	for(U8 f = 0; f < 6; ++f)
 	{
@@ -534,8 +534,8 @@ void ProbeReflections::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 	start = I32(startu);
 	end = I32(endu);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-	cmdb->setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+	cmdb.setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
 
 	I32 drawcallCount = 0;
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
@@ -554,8 +554,8 @@ void ProbeReflections::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 		if(localStart < localEnd)
 		{
 			const U32 rez = m_shadowMapping.m_rtDescr.m_height;
-			cmdb->setViewport(rez * faceIdx, 0, rez, rez);
-			cmdb->setScissor(rez * faceIdx, 0, rez, rez);
+			cmdb.setViewport(rez * faceIdx, 0, rez, rez);
+			cmdb.setScissor(rez * faceIdx, 0, rez, rez);
 
 			ANKI_ASSERT(localStart >= 0 && localEnd <= faceDrawcallCount);
 

AnKi/Renderer/Renderer.cpp

@@ -693,7 +693,7 @@ void Renderer::gpuSceneCopy(RenderingContext& ctx)
 		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([](RenderPassWorkContext& rgraphCtx) {
-			GpuSceneMicroPatcher::getSingleton().patchGpuScene(*rgraphCtx.m_commandBuffer.get());
+			GpuSceneMicroPatcher::getSingleton().patchGpuScene(*rgraphCtx.m_commandBuffer);
 		});
 	}
 }

AnKi/Renderer/RendererObject.cpp

@@ -21,27 +21,27 @@ void* RendererObject::allocateRebarStagingMemory(PtrSize size, RebarAllocation&
 	return RebarTransientMemoryPool::getSingleton().allocateFrame(size, token);
 }
 
-void RendererObject::bindUniforms(CommandBufferPtr& cmdb, U32 set, U32 binding, const RebarAllocation& token) const
+void RendererObject::bindUniforms(CommandBuffer& cmdb, U32 set, U32 binding, const RebarAllocation& token) const
 {
 	if(!token.isUnused())
 	{
-		cmdb->bindUniformBuffer(set, binding, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, token.m_range);
+		cmdb.bindUniformBuffer(set, binding, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, token.m_range);
 	}
 	else
 	{
-		cmdb->bindUniformBuffer(set, binding, &getRenderer().getDummyBuffer(), 0, getRenderer().getDummyBuffer().getSize());
+		cmdb.bindUniformBuffer(set, binding, &getRenderer().getDummyBuffer(), 0, getRenderer().getDummyBuffer().getSize());
 	}
 }
 
-void RendererObject::bindStorage(CommandBufferPtr& cmdb, U32 set, U32 binding, const RebarAllocation& token) const
+void RendererObject::bindStorage(CommandBuffer& cmdb, U32 set, U32 binding, const RebarAllocation& token) const
 {
 	if(!token.isUnused())
 	{
-		cmdb->bindStorageBuffer(set, binding, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, token.m_range);
+		cmdb.bindStorageBuffer(set, binding, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, token.m_range);
 	}
 	else
 	{
-		cmdb->bindStorageBuffer(set, binding, &getRenderer().getDummyBuffer(), 0, getRenderer().getDummyBuffer().getSize());
+		cmdb.bindStorageBuffer(set, binding, &getRenderer().getDummyBuffer(), 0, getRenderer().getDummyBuffer().getSize());
 	}
 }
 

AnKi/Renderer/RendererObject.h

@@ -43,26 +43,26 @@ protected:
 	U32 computeNumberOfSecondLevelCommandBuffers(U32 drawcallCount) const;
 
 	/// Used in fullscreen quad draws.
-	static void drawQuad(CommandBufferPtr& cmdb)
+	static void drawQuad(CommandBuffer& cmdb)
 	{
-		cmdb->draw(PrimitiveTopology::kTriangles, 3, 1);
+		cmdb.draw(PrimitiveTopology::kTriangles, 3, 1);
 	}
 
 	/// Dispatch a compute job equivelent to drawQuad
-	static void dispatchPPCompute(CommandBufferPtr& cmdb, U32 workgroupSizeX, U32 workgroupSizeY, U32 outImageWidth, U32 outImageHeight)
+	static void dispatchPPCompute(CommandBuffer& cmdb, U32 workgroupSizeX, U32 workgroupSizeY, U32 outImageWidth, U32 outImageHeight)
 	{
 		const U32 sizeX = (outImageWidth + workgroupSizeX - 1) / workgroupSizeX;
 		const U32 sizeY = (outImageHeight + workgroupSizeY - 1) / workgroupSizeY;
-		cmdb->dispatchCompute(sizeX, sizeY, 1);
+		cmdb.dispatchCompute(sizeX, sizeY, 1);
 	}
 
-	static void dispatchPPCompute(CommandBufferPtr& cmdb, U32 workgroupSizeX, U32 workgroupSizeY, U32 workgroupSizeZ, U32 outImageWidth,
+	static void dispatchPPCompute(CommandBuffer& cmdb, U32 workgroupSizeX, U32 workgroupSizeY, U32 workgroupSizeZ, U32 outImageWidth,
 								  U32 outImageHeight, U32 outImageDepth)
 	{
 		const U32 sizeX = (outImageWidth + workgroupSizeX - 1) / workgroupSizeX;
 		const U32 sizeY = (outImageHeight + workgroupSizeY - 1) / workgroupSizeY;
 		const U32 sizeZ = (outImageDepth + workgroupSizeZ - 1) / workgroupSizeZ;
-		cmdb->dispatchCompute(sizeX, sizeY, sizeZ);
+		cmdb.dispatchCompute(sizeX, sizeY, sizeZ);
 	}
 
 	template<typename TPtr>
@@ -71,10 +71,10 @@ protected:
 		return static_cast<TPtr>(allocateRebarStagingMemory(size, token));
 	}
 
-	void bindUniforms(CommandBufferPtr& cmdb, U32 set, U32 binding, const RebarAllocation& token) const;
+	void bindUniforms(CommandBuffer& cmdb, U32 set, U32 binding, const RebarAllocation& token) const;
 
 	template<typename TPtr>
-	TPtr allocateAndBindUniforms(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 binding)
+	TPtr allocateAndBindUniforms(PtrSize size, CommandBuffer& cmdb, U32 set, U32 binding)
 	{
 		RebarAllocation token;
 		TPtr ptr = allocateUniforms<TPtr>(size, token);
@@ -88,10 +88,10 @@ protected:
 		return static_cast<TPtr>(allocateRebarStagingMemory(size, token));
 	}
 
-	void bindStorage(CommandBufferPtr& cmdb, U32 set, U32 binding, const RebarAllocation& token) const;
+	void bindStorage(CommandBuffer& cmdb, U32 set, U32 binding, const RebarAllocation& token) const;
 
 	template<typename TPtr>
-	TPtr allocateAndBindStorage(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 binding)
+	TPtr allocateAndBindStorage(PtrSize size, CommandBuffer& cmdb, U32 set, U32 binding)
 	{
 		RebarAllocation token;
 		TPtr ptr = allocateStorage<TPtr>(size, token);

AnKi/Renderer/RtShadows.cpp

@@ -420,9 +420,9 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_rtLibraryGrProg.get());
+	cmdb.bindShaderProgram(m_rtLibraryGrProg.get());
 
 	// Allocate, set and bind global uniforms
 	{
@@ -432,18 +432,18 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 
 		memset(globalUniforms, 0, sizeof(*globalUniforms)); // Don't care for now
 
-		cmdb->bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms),
-								&RebarTransientMemoryPool::getSingleton().getBuffer(), globalUniformsToken.m_offset, globalUniformsToken.m_range);
+		cmdb.bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms),
+							   &RebarTransientMemoryPool::getSingleton().getBuffer(), globalUniformsToken.m_offset, globalUniformsToken.m_range);
 	}
 
 	// More globals
-	cmdb->bindAllBindless(U32(MaterialSet::kBindless));
-	cmdb->bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler), getRenderer().getSamplers().m_trilinearRepeat.get());
-	cmdb->bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindAllBindless(U32(MaterialSet::kBindless));
+	cmdb.bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler), getRenderer().getSamplers().m_trilinearRepeat.get());
+	cmdb.bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
 #define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
-	cmdb->bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
-									&UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
+	cmdb.bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
+								   &UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize, Format::k##fmt);
 #include <AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h>
 
 	constexpr U32 kSet = 2;
@@ -456,13 +456,13 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 
 	bindStorage(cmdb, kSet, 4, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindSampler(kSet, 5, getRenderer().getSamplers().m_trilinearRepeat.get());
+	cmdb.bindSampler(kSet, 5, getRenderer().getSamplers().m_trilinearRepeat.get());
 
 	rgraphCtx.bindImage(kSet, 6, m_runCtx.m_intermediateShadowsRts[0]);
 
 	rgraphCtx.bindColorTexture(kSet, 7, m_runCtx.m_historyRt);
-	cmdb->bindSampler(kSet, 8, getRenderer().getSamplers().m_trilinearClamp.get());
-	cmdb->bindSampler(kSet, 9, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(kSet, 8, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(kSet, 9, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindTexture(kSet, 10, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(kSet, 11, getRenderer().getMotionVectors().getMotionVectorsRt());
 	rgraphCtx.bindColorTexture(kSet, 12, getRenderer().getMotionVectors().getHistoryLengthRt());
@@ -470,27 +470,27 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 	rgraphCtx.bindAccelerationStructure(kSet, 14, getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle());
 	rgraphCtx.bindColorTexture(kSet, 15, m_runCtx.m_prevMomentsRt);
 	rgraphCtx.bindImage(kSet, 16, m_runCtx.m_currentMomentsRt);
-	cmdb->bindTexture(kSet, 17, &m_blueNoiseImage->getTextureView());
+	cmdb.bindTexture(kSet, 17, &m_blueNoiseImage->getTextureView());
 
 	RtShadowsUniforms unis;
 	for(U32 i = 0; i < kMaxRtShadowLayers; ++i)
 	{
 		unis.historyRejectFactor[i] = F32(m_runCtx.m_layersWithRejectedHistory.get(i));
 	}
-	cmdb->setPushConstants(&unis, sizeof(unis));
+	cmdb.setPushConstants(&unis, sizeof(unis));
 
-	cmdb->traceRays(m_runCtx.m_sbtBuffer.get(), m_runCtx.m_sbtOffset, m_sbtRecordSize, m_runCtx.m_hitGroupCount, 1,
-					getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, 1);
+	cmdb.traceRays(m_runCtx.m_sbtBuffer.get(), m_runCtx.m_sbtOffset, m_sbtRecordSize, m_runCtx.m_hitGroupCount, 1,
+				   getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, 1);
 }
 
 void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram((m_runCtx.m_denoiseOrientation == 0) ? m_grDenoiseHorizontalProg.get() : m_grDenoiseVerticalProg.get());
+	cmdb.bindShaderProgram((m_runCtx.m_denoiseOrientation == 0) ? m_grDenoiseHorizontalProg.get() : m_grDenoiseVerticalProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_intermediateShadowsRts[m_runCtx.m_denoiseOrientation]);
 	rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(0, 4, getRenderer().getGBuffer().getColorRt(2));
@@ -502,7 +502,7 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 	RtShadowsDenoiseUniforms unis;
 	unis.invViewProjMat = ctx.m_matrices.m_invertedViewProjectionJitter;
 	unis.time = F32(GlobalFrameIndex::getSingleton().m_value);
-	cmdb->setPushConstants(&unis, sizeof(unis));
+	cmdb.setPushConstants(&unis, sizeof(unis));
 
 	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
 
@@ -511,12 +511,12 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 
 void RtShadows::runSvgfVariance(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_svgfVarianceGrProg.get());
+	cmdb.bindShaderProgram(m_svgfVarianceGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_intermediateShadowsRts[0]);
 	rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_currentMomentsRt);
@@ -527,29 +527,29 @@ void RtShadows::runSvgfVariance(const RenderingContext& ctx, RenderPassWorkConte
 	rgraphCtx.bindImage(0, 7, m_runCtx.m_varianceRts[1]);
 
 	const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
-	cmdb->setPushConstants(&invProjMat, sizeof(invProjMat));
+	cmdb.setPushConstants(&invProjMat, sizeof(invProjMat));
 
 	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
 }
 
 void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	const Bool lastPass = m_runCtx.m_atrousPassIdx == m_atrousPassCount - 1;
 	const U32 readRtIdx = (m_runCtx.m_atrousPassIdx + 1) & 1;
 
 	if(lastPass)
 	{
-		cmdb->bindShaderProgram(m_svgfAtrousLastPassGrProg.get());
+		cmdb.bindShaderProgram(m_svgfAtrousLastPassGrProg.get());
 	}
 	else
 	{
-		cmdb->bindShaderProgram(m_svgfAtrousGrProg.get());
+		cmdb.bindShaderProgram(m_svgfAtrousGrProg.get());
 	}
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
 	rgraphCtx.bindTexture(0, 2, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_intermediateShadowsRts[readRtIdx]);
@@ -566,7 +566,7 @@ void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext
 	}
 
 	const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
-	cmdb->setPushConstants(&invProjMat, sizeof(invProjMat));
+	cmdb.setPushConstants(&invProjMat, sizeof(invProjMat));
 
 	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
 
@@ -575,12 +575,12 @@ void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext
 
 void RtShadows::runUpscale(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_upscaleGrProg.get());
+	cmdb.bindShaderProgram(m_upscaleGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_historyRt);
 	rgraphCtx.bindImage(0, 3, m_runCtx.m_upscaledRt);

AnKi/Renderer/Scale.cpp

@@ -311,14 +311,14 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 
 void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
 	const RenderTargetHandle inRt = getRenderer().getTemporalAA().getTonemappedRt();
 	const RenderTargetHandle outRt = m_runCtx.m_upscaledTonemappedRt;
 
-	cmdb->bindShaderProgram(m_scaleGrProg.get());
+	cmdb.bindShaderProgram(m_scaleGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	if(preferCompute)
@@ -346,7 +346,7 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 
 		pc.m_viewportSize = getRenderer().getPostProcessResolution();
 
-		cmdb->setPushConstants(&pc, sizeof(pc));
+		cmdb.setPushConstants(&pc, sizeof(pc));
 	}
 	else if(preferCompute)
 	{
@@ -359,7 +359,7 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 		pc.m_viewportSize = Vec2(getRenderer().getPostProcessResolution());
 		pc.m_viewportSizeU = getRenderer().getPostProcessResolution();
 
-		cmdb->setPushConstants(&pc, sizeof(pc));
+		cmdb.setPushConstants(&pc, sizeof(pc));
 	}
 
 	if(preferCompute)
@@ -368,21 +368,21 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
 void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
 	const RenderTargetHandle inRt = m_runCtx.m_tonemappedRt;
 	const RenderTargetHandle outRt = m_runCtx.m_sharpenedRt;
 
-	cmdb->bindShaderProgram(m_sharpenGrProg.get());
+	cmdb.bindShaderProgram(m_sharpenGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	if(preferCompute)
@@ -408,7 +408,7 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 
 	pc.m_viewportSize = getRenderer().getPostProcessResolution();
 
-	cmdb->setPushConstants(&pc, sizeof(pc));
+	cmdb.setPushConstants(&pc, sizeof(pc));
 
 	if(preferCompute)
 	{
@@ -416,8 +416,8 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
@@ -429,7 +429,7 @@ void Scale::runGrUpscaling(RenderingContext& ctx, RenderPassWorkContext& rgraphC
 	// In [-texSize / 2, texSize / 2] -> sub-pixel space {-0.5, 0.5}
 	const Vec2 jitterOffset = ctx.m_matrices.m_jitter.getTranslationPart().xy() * srcRes * 0.5f;
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 	TextureViewPtr srcView = rgraphCtx.createTextureView(getRenderer().getLightShading().getRt());
 	TextureViewPtr motionVectorsView = rgraphCtx.createTextureView(getRenderer().getMotionVectors().getMotionVectorsRt());
@@ -437,20 +437,20 @@ void Scale::runGrUpscaling(RenderingContext& ctx, RenderPassWorkContext& rgraphC
 	TextureViewPtr exposureView = rgraphCtx.createTextureView(getRenderer().getTonemapping().getRt());
 	TextureViewPtr dstView = rgraphCtx.createTextureView(m_runCtx.m_upscaledHdrRt);
 
-	cmdb->upscale(m_grUpscaler.get(), srcView.get(), dstView.get(), motionVectorsView.get(), depthView.get(), exposureView.get(), reset, jitterOffset,
-				  mvScale);
+	cmdb.upscale(m_grUpscaler.get(), srcView.get(), dstView.get(), motionVectorsView.get(), depthView.get(), exposureView.get(), reset, jitterOffset,
+				 mvScale);
 }
 
 void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
 	const RenderTargetHandle inRt = m_runCtx.m_upscaledHdrRt;
 	const RenderTargetHandle outRt = m_runCtx.m_tonemappedRt;
 
-	cmdb->bindShaderProgram(m_tonemapGrProg.get());
+	cmdb.bindShaderProgram(m_tonemapGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
@@ -465,15 +465,15 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 		} pc;
 		pc.m_viewportSizeOverOne = 1.0f / Vec2(getRenderer().getPostProcessResolution());
 		pc.m_viewportSize = getRenderer().getPostProcessResolution();
-		cmdb->setPushConstants(&pc, sizeof(pc));
+		cmdb.setPushConstants(&pc, sizeof(pc));
 		rgraphCtx.bindImage(0, 3, outRt);
 
 		dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/ShadowMapping.cpp

@@ -563,10 +563,10 @@ void ShadowMapping::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 	ANKI_ASSERT(m_runCtx.m_workItems.getSize());
 	ANKI_TRACE_SCOPED_EVENT(RSm);
 
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 	const U threadIdx = rgraphCtx.m_currentSecondLevelCommandBufferIndex;
 
-	cmdb->setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
+	cmdb.setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
 
 	for(ThreadWorkItem& work : m_runCtx.m_workItems)
 	{
@@ -576,20 +576,20 @@ void ShadowMapping::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 		}
 
 		// Set state
-		cmdb->setViewport(work.m_viewport[0], work.m_viewport[1], work.m_viewport[2], work.m_viewport[3]);
-		cmdb->setScissor(work.m_viewport[0], work.m_viewport[1], work.m_viewport[2], work.m_viewport[3]);
+		cmdb.setViewport(work.m_viewport[0], work.m_viewport[1], work.m_viewport[2], work.m_viewport[3]);
+		cmdb.setScissor(work.m_viewport[0], work.m_viewport[1], work.m_viewport[2], work.m_viewport[3]);
 
 		// The 1st drawcall will clear the depth buffer
 		if(work.m_firstRenderableElement == 0)
 		{
-			cmdb->bindShaderProgram(m_clearDepthGrProg.get());
-			cmdb->setDepthCompareOperation(CompareOperation::kAlways);
-			cmdb->setPolygonOffset(0.0f, 0.0f);
-			cmdb->draw(PrimitiveTopology::kTriangles, 3, 1);
+			cmdb.bindShaderProgram(m_clearDepthGrProg.get());
+			cmdb.setDepthCompareOperation(CompareOperation::kAlways);
+			cmdb.setPolygonOffset(0.0f, 0.0f);
+			cmdb.draw(PrimitiveTopology::kTriangles, 3, 1);
 
 			// Restore state
-			cmdb->setDepthCompareOperation(CompareOperation::kLess);
-			cmdb->setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
+			cmdb.setDepthCompareOperation(CompareOperation::kLess);
+			cmdb.setPolygonOffset(kShadowsPolygonOffsetFactor, kShadowsPolygonOffsetUnits);
 		}
 
 		RenderableDrawerArguments args;

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -100,9 +100,9 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 
 void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg.get());
+	cmdb.bindShaderProgram(m_grProg.get());
 
 	bindUniforms(cmdb, 0, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 1, ClusteredObjectType::kPointLight);
@@ -110,9 +110,9 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 	rgraphCtx.bindColorTexture(0, 3, getRenderer().getShadowMapping().getShadowmapRt());
 	bindStorage(cmdb, 0, 4, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClamp.get());
-	cmdb->bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClampShadow.get());
-	cmdb->bindSampler(0, 7, getRenderer().getSamplers().m_trilinearRepeat.get());
+	cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClampShadow.get());
+	cmdb.bindSampler(0, 7, getRenderer().getSamplers().m_trilinearRepeat.get());
 
 	if(m_quarterRez)
 	{
@@ -122,7 +122,7 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 	{
 		rgraphCtx.bindTexture(0, 8, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	}
-	cmdb->bindTexture(0, 9, &m_noiseImage->getTextureView());
+	cmdb.bindTexture(0, 9, &m_noiseImage->getTextureView());
 
 	if(ConfigSet::getSingleton().getRPreferCompute())
 	{
@@ -131,8 +131,8 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, m_rtDescr.m_width, m_rtDescr.m_height);
-		cmdb->draw(PrimitiveTopology::kTriangles, 3);
+		cmdb.setViewport(0, 0, m_rtDescr.m_width, m_rtDescr.m_height);
+		cmdb.draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/TemporalAA.cpp

@@ -129,11 +129,11 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	prpass->newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
 
 	prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
-		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg.get());
+		cmdb.bindShaderProgram(m_grProg.get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 1, getRenderer().getLightShading().getRt());
 		rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_historyRt);
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getMotionVectors().getMotionVectorsRt());
@@ -148,9 +148,9 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
+			cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
-			cmdb->draw(PrimitiveTopology::kTriangles, 3);
+			cmdb.draw(PrimitiveTopology::kTriangles, 3);
 		}
 	});
 }

AnKi/Renderer/Tonemapping.cpp

@@ -64,16 +64,16 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("AvgLuminance");
 
 	pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
-		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg.get());
+		cmdb.bindShaderProgram(m_grProg.get());
 		rgraphCtx.bindImage(0, 1, m_runCtx.m_exposureLuminanceHandle);
 
 		TextureSubresourceInfo inputTexSubresource;
 		inputTexSubresource.m_firstMipmap = m_inputTexMip;
 		rgraphCtx.bindTexture(0, 0, getRenderer().getDownscaleBlur().getRt(), inputTexSubresource);
 
-		cmdb->dispatchCompute(1, 1, 1);
+		cmdb.dispatchCompute(1, 1, 1);
 	});
 
 	TextureSubresourceInfo inputTexSubresource;

AnKi/Renderer/TraditionalDeferredShading.cpp

@@ -142,10 +142,10 @@ void TraditionalDeferredLightShading::createProxyMeshes()
 	GrManager::getSingleton().finish();
 }
 
-void TraditionalDeferredLightShading::bindVertexIndexBuffers(ProxyType proxyType, CommandBufferPtr& cmdb, U32& indexCount) const
+void TraditionalDeferredLightShading::bindVertexIndexBuffers(ProxyType proxyType, CommandBuffer& cmdb, U32& indexCount) const
 {
 	// Attrib
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
+	cmdb.setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
 
 	// Vert buff
 	PtrSize offset;
@@ -157,7 +157,7 @@ void TraditionalDeferredLightShading::bindVertexIndexBuffers(ProxyType proxyType
 	{
 		offset = sizeof(kIcosphereVertices);
 	}
-	cmdb->bindVertexBuffer(0, m_proxyVolumesBuffer.get(), offset, sizeof(Vec3));
+	cmdb.bindVertexBuffer(0, m_proxyVolumesBuffer.get(), offset, sizeof(Vec3));
 
 	// Idx buff
 	if(proxyType == ProxyType::kProxySphere)
@@ -171,30 +171,30 @@ void TraditionalDeferredLightShading::bindVertexIndexBuffers(ProxyType proxyType
 		indexCount = sizeof(kConeIndices) / sizeof(U16);
 	}
 
-	cmdb->bindIndexBuffer(m_proxyVolumesBuffer.get(), offset, IndexType::kU16);
+	cmdb.bindIndexBuffer(m_proxyVolumesBuffer.get(), offset, IndexType::kU16);
 }
 
 void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShadingDrawInfo& info)
 {
-	CommandBufferPtr& cmdb = info.m_commandBuffer;
+	CommandBuffer& cmdb = *info.m_commandBuffer;
 	RenderPassWorkContext& rgraphCtx = *info.m_renderpassContext;
 
 	// Set common state for all
-	cmdb->setViewport(info.m_viewport.x(), info.m_viewport.y(), info.m_viewport.z(), info.m_viewport.w());
+	cmdb.setViewport(info.m_viewport.x(), info.m_viewport.y(), info.m_viewport.z(), info.m_viewport.w());
 
 	// Skybox first
 	{
 		const Bool isSolidColor = info.m_skybox->m_skyboxTexture == nullptr;
 
-		cmdb->bindShaderProgram(m_skyboxGrProgs[!isSolidColor].get());
+		cmdb.bindShaderProgram(m_skyboxGrProgs[!isSolidColor].get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 		rgraphCtx.bindTexture(0, 1, info.m_gbufferDepthRenderTarget, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(!isSolidColor)
 		{
-			cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeatAniso.get());
-			cmdb->bindTexture(0, 3, info.m_skybox->m_skyboxTexture);
+			cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeatAniso.get());
+			cmdb.bindTexture(0, 3, info.m_skybox->m_skyboxTexture);
 		}
 
 		DeferredSkyboxUniforms unis;
@@ -203,17 +203,17 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		unis.m_inputTexUvScale = info.m_gbufferTexCoordsScale;
 		unis.m_invertedViewProjectionMat = info.m_invViewProjectionMatrix;
 		unis.m_cameraPos = info.m_cameraPosWSpace.xyz();
-		cmdb->setPushConstants(&unis, sizeof(unis));
+		cmdb.setPushConstants(&unis, sizeof(unis));
 
 		drawQuad(cmdb);
 	}
 
 	// Set common state for all light drawcalls
 	{
-		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
+		cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
 
 		// NOTE: Use nearest sampler because we don't want the result to sample the near tiles
-		cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp.get());
+		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 		rgraphCtx.bindColorTexture(0, 3, info.m_gbufferRenderTargets[0]);
 		rgraphCtx.bindColorTexture(0, 4, info.m_gbufferRenderTargets[1]);
@@ -222,7 +222,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		rgraphCtx.bindTexture(0, 6, info.m_gbufferDepthRenderTarget, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		// Set shadowmap resources
-		cmdb->bindSampler(0, 7, m_shadowSampler.get());
+		cmdb.bindSampler(0, 7, m_shadowSampler.get());
 
 		if(info.m_directionalLight && info.m_directionalLight->hasShadow())
 		{
@@ -242,7 +242,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 	{
 		ANKI_ASSERT(info.m_directionalLight->m_uuid && info.m_directionalLight->m_shadowCascadeCount == 1);
 
-		cmdb->bindShaderProgram(m_dirLightGrProg[info.m_computeSpecular].get());
+		cmdb.bindShaderProgram(m_dirLightGrProg[info.m_computeSpecular].get());
 
 		DeferredDirectionalLightUniforms* unis =
 			allocateAndBindUniforms<DeferredDirectionalLightUniforms*>(sizeof(DeferredDirectionalLightUniforms), cmdb, 0, 1);
@@ -274,12 +274,12 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 	}
 
 	// Set other light state
-	cmdb->setCullMode(FaceSelectionBit::kFront);
+	cmdb.setCullMode(FaceSelectionBit::kFront);
 
 	// Do point lights
 	U32 indexCount;
 	bindVertexIndexBuffers(ProxyType::kProxySphere, cmdb, indexCount);
-	cmdb->bindShaderProgram(m_plightGrProg[info.m_computeSpecular].get());
+	cmdb.bindShaderProgram(m_plightGrProg[info.m_computeSpecular].get());
 
 	for(const PointLightQueueElement& plightEl : info.m_pointLights)
 	{
@@ -303,12 +303,12 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		light->m_diffuseColor = plightEl.m_diffuseColor;
 
 		// Draw
-		cmdb->drawIndexed(PrimitiveTopology::kTriangles, indexCount);
+		cmdb.drawIndexed(PrimitiveTopology::kTriangles, indexCount);
 	}
 
 	// Do spot lights
 	bindVertexIndexBuffers(ProxyType::kProxyCone, cmdb, indexCount);
-	cmdb->bindShaderProgram(m_slightGrProg[info.m_computeSpecular].get());
+	cmdb.bindShaderProgram(m_slightGrProg[info.m_computeSpecular].get());
 
 	for(const SpotLightQueueElement& splightEl : info.m_spotLights)
 	{
@@ -348,12 +348,12 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		light->m_innerCos = cos(splightEl.m_innerAngle / 2.0f);
 
 		// Draw
-		cmdb->drawIndexed(PrimitiveTopology::kTriangles, indexCount);
+		cmdb.drawIndexed(PrimitiveTopology::kTriangles, indexCount);
 	}
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
-	cmdb->setCullMode(FaceSelectionBit::kBack);
+	cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb.setCullMode(FaceSelectionBit::kBack);
 }
 
 } // end namespace anki

AnKi/Renderer/TraditionalDeferredShading.h

@@ -31,7 +31,7 @@ public:
 	ConstWeakArray<PointLightQueueElement> m_pointLights;
 	ConstWeakArray<SpotLightQueueElement> m_spotLights;
 	const SkyboxQueueElement* m_skybox = nullptr;
-	CommandBufferPtr m_commandBuffer;
+	CommandBuffer* m_commandBuffer = nullptr;
 	Bool m_computeSpecular = false;
 
 	// Render targets
@@ -74,7 +74,7 @@ private:
 
 	SamplerPtr m_shadowSampler;
 
-	void bindVertexIndexBuffers(ProxyType proxyType, CommandBufferPtr& cmdb, U32& indexCount) const;
+	void bindVertexIndexBuffers(ProxyType proxyType, CommandBuffer& cmdb, U32& indexCount) const;
 
 	void createProxyMeshes();
 };

AnKi/Renderer/UiStage.cpp

@@ -21,7 +21,7 @@ Error UiStage::init()
 	return Error::kNone;
 }
 
-void UiStage::draw(U32 width, U32 height, RenderingContext& ctx, CommandBufferPtr& cmdb)
+void UiStage::draw(U32 width, U32 height, RenderingContext& ctx, CommandBuffer& cmdb)
 {
 	// Early exit
 	if(ctx.m_renderQueue->m_uis.getSize() == 0)
@@ -43,9 +43,9 @@ void UiStage::draw(U32 width, U32 height, RenderingContext& ctx, CommandBufferPt
 	m_canvas->appendToCommandBuffer(cmdb);
 
 	// UI messes with the state, restore it
-	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
-	cmdb->setBlendOperation(0, BlendOperation::kAdd);
-	cmdb->setCullMode(FaceSelectionBit::kBack);
+	cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb.setBlendOperation(0, BlendOperation::kAdd);
+	cmdb.setCullMode(FaceSelectionBit::kBack);
 }
 
 } // end namespace anki

AnKi/Renderer/UiStage.h

@@ -20,7 +20,7 @@ class UiStage : public RendererObject
 public:
 	Error init();
 
-	void draw(U32 width, U32 height, RenderingContext& ctx, CommandBufferPtr& cmdb);
+	void draw(U32 width, U32 height, RenderingContext& ctx, CommandBuffer& cmdb);
 
 private:
 	FontPtr m_font;

AnKi/Renderer/VolumetricFog.cpp

@@ -58,11 +58,11 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) -> void {
-		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg.get());
+		cmdb.bindShaderProgram(m_grProg.get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+		cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 		rgraphCtx.bindColorTexture(0, 1, getRenderer().getVolumetricLightingAccumulation().getRt());
 
 		rgraphCtx.bindImage(0, 2, m_runCtx.m_rt, TextureSubresourceInfo());
@@ -78,7 +78,7 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 		regs.m_volumeSize = UVec3(m_volumeSize);
 		regs.m_maxZSplitsToProcessf = F32(m_finalZSplit + 1);
 
-		cmdb->setPushConstants(&regs, sizeof(regs));
+		cmdb.setPushConstants(&regs, sizeof(regs));
 
 		dispatchPPCompute(cmdb, m_workgroupSize[0], m_workgroupSize[1], m_volumeSize[0], m_volumeSize[1]);
 	});

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -88,18 +88,18 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg.get());
+	cmdb.bindShaderProgram(m_grProg.get());
 
 	// Bind all
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeat.get());
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
-	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClampShadow.get());
+	cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeat.get());
+	cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
+	cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClampShadow.get());
 
 	rgraphCtx.bindImage(0, 3, m_runCtx.m_rts[1], TextureSubresourceInfo());
 
-	cmdb->bindTexture(0, 4, &m_noiseImage->getTextureView());
+	cmdb.bindTexture(0, 4, &m_noiseImage->getTextureView());
 
 	rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_rts[0]);
 
@@ -113,7 +113,7 @@ void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPass
 	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 11, ClusteredObjectType::kFogDensityVolume);
 	bindStorage(cmdb, 0, 12, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindAllBindless(1);
+	cmdb.bindAllBindless(1);
 
 	VolumetricLightingUniforms unis;
 	const SkyboxQueueElement& queueEl = ctx.m_renderQueue->m_skybox;
@@ -133,7 +133,7 @@ void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPass
 	}
 	unis.m_volumeSize = UVec3(m_volumeSize);
 	unis.m_maxZSplitsToProcessf = F32(m_finalZSplit + 1);
-	cmdb->setPushConstants(&unis, sizeof(unis));
+	cmdb.setPushConstants(&unis, sizeof(unis));
 
 	dispatchPPCompute(cmdb, m_workgroupSize[0], m_workgroupSize[1], m_workgroupSize[2], m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]);
 }

AnKi/Renderer/VrsSriGeneration.cpp

@@ -136,15 +136,15 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_grProg.get());
+			cmdb.bindShaderProgram(m_grProg.get());
 
 			rgraphCtx.bindColorTexture(0, 0, getRenderer().getLightShading().getRt());
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
+			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_rt);
 			const Vec4 pc(1.0f / Vec2(getRenderer().getInternalResolution()), ConfigSet::getSingleton().getRVrsThreshold(), 0.0f);
-			cmdb->setPushConstants(&pc, sizeof(pc));
+			cmdb.setPushConstants(&pc, sizeof(pc));
 
 			const U32 fakeWorkgroupSizeXorY = m_sriTexelDimension;
 			dispatchPPCompute(cmdb, fakeWorkgroupSizeXorY, fakeWorkgroupSizeXorY, getRenderer().getInternalResolution().x(),
@@ -162,15 +162,15 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 rezDownscaled = (getRenderer().getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
 
-			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_downscaleGrProg.get());
+			cmdb.bindShaderProgram(m_downscaleGrProg.get());
 
 			rgraphCtx.bindColorTexture(0, 0, m_runCtx.m_rt);
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
+			cmdb.bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_downscaledRt);
 			const Vec4 pc(1.0f / Vec2(rezDownscaled), 0.0f, 0.0f);
-			cmdb->setPushConstants(&pc, sizeof(pc));
+			cmdb.setPushConstants(&pc, sizeof(pc));
 
 			dispatchPPCompute(cmdb, 8, 8, rezDownscaled.x(), rezDownscaled.y());
 		});

AnKi/Ui/Canvas.cpp

@@ -173,7 +173,7 @@ void Canvas::pushFont(const FontPtr& font, U32 fontHeight)
 	ImGui::PushFont(&font->getImFont(fontHeight));
 }
 
-void Canvas::appendToCommandBuffer(CommandBufferPtr cmdb)
+void Canvas::appendToCommandBuffer(CommandBuffer& cmdb)
 {
 	appendToCommandBufferInternal(cmdb);
 
@@ -183,7 +183,7 @@ void Canvas::appendToCommandBuffer(CommandBufferPtr cmdb)
 	m_references.destroy();
 }
 
-void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
+void Canvas::appendToCommandBufferInternal(CommandBuffer& cmdb)
 {
 	ImGui::PopFont();
 	ImGui::Render();
@@ -213,19 +213,19 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 		}
 	}
 
-	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
-	cmdb->setCullMode(FaceSelectionBit::kNone);
+	cmdb.setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
+	cmdb.setCullMode(FaceSelectionBit::kNone);
 
 	const F32 fbWidth = drawData.DisplaySize.x * drawData.FramebufferScale.x;
 	const F32 fbHeight = drawData.DisplaySize.y * drawData.FramebufferScale.y;
-	cmdb->setViewport(0, 0, U32(fbWidth), U32(fbHeight));
+	cmdb.setViewport(0, 0, U32(fbWidth), U32(fbHeight));
 
-	cmdb->bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), vertsToken.m_offset, sizeof(ImDrawVert));
-	cmdb->setVertexAttribute(0, 0, Format::kR32G32_Sfloat, 0);
-	cmdb->setVertexAttribute(1, 0, Format::kR8G8B8A8_Unorm, sizeof(Vec2) * 2);
-	cmdb->setVertexAttribute(2, 0, Format::kR32G32_Sfloat, sizeof(Vec2));
+	cmdb.bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), vertsToken.m_offset, sizeof(ImDrawVert));
+	cmdb.setVertexAttribute(0, 0, Format::kR32G32_Sfloat, 0);
+	cmdb.setVertexAttribute(1, 0, Format::kR8G8B8A8_Unorm, sizeof(Vec2) * 2);
+	cmdb.setVertexAttribute(2, 0, Format::kR32G32_Sfloat, sizeof(Vec2));
 
-	cmdb->bindIndexBuffer(&RebarTransientMemoryPool::getSingleton().getBuffer(), indicesToken.m_offset, IndexType::kU16);
+	cmdb.bindIndexBuffer(&RebarTransientMemoryPool::getSingleton().getBuffer(), indicesToken.m_offset, IndexType::kU16);
 
 	// Will project scissor/clipping rectangles into framebuffer space
 	const Vec2 clipOff = drawData.DisplayPos; // (0,0) unless using multi-viewports
@@ -267,7 +267,7 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 					}
 
 					// Apply scissor/clipping rectangle
-					cmdb->setScissor(U32(clipRect.x()), U32(clipRect.y()), U32(clipRect.z() - clipRect.x()), U32(clipRect.w() - clipRect.y()));
+					cmdb.setScissor(U32(clipRect.x()), U32(clipRect.y()), U32(clipRect.z() - clipRect.x()), U32(clipRect.w() - clipRect.y()));
 
 					UiImageId id(pcmd.TextureId);
 					const UiImageIdExtra* idExtra = nullptr;
@@ -285,23 +285,22 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 					// Bind program
 					if(idExtra && idExtra->m_customProgram.isCreated())
 					{
-						cmdb->bindShaderProgram(idExtra->m_customProgram.get());
+						cmdb.bindShaderProgram(idExtra->m_customProgram.get());
 					}
 					else if(textureView.isCreated())
 					{
-						cmdb->bindShaderProgram(m_grProgs[kRgbaTex].get());
+						cmdb.bindShaderProgram(m_grProgs[kRgbaTex].get());
 					}
 					else
 					{
-						cmdb->bindShaderProgram(m_grProgs[kNoTex].get());
+						cmdb.bindShaderProgram(m_grProgs[kNoTex].get());
 					}
 
 					// Bindings
 					if(textureView.isCreated())
 					{
-						cmdb->bindSampler(0, 0,
-										  (id.m_bits.m_pointSampling) ? m_nearestNearestRepeatSampler.get() : m_linearLinearRepeatSampler.get());
-						cmdb->bindTexture(0, 1, textureView.get());
+						cmdb.bindSampler(0, 0, (id.m_bits.m_pointSampling) ? m_nearestNearestRepeatSampler.get() : m_linearLinearRepeatSampler.get());
+						cmdb.bindTexture(0, 1, textureView.get());
 					}
 
 					// Push constants
@@ -323,10 +322,10 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 
 						extraPushConstantsSize = idExtra->m_extraPushConstantsSize;
 					}
-					cmdb->setPushConstants(&pc, sizeof(Vec4) + extraPushConstantsSize);
+					cmdb.setPushConstants(&pc, sizeof(Vec4) + extraPushConstantsSize);
 
 					// Draw
-					cmdb->drawIndexed(PrimitiveTopology::kTriangles, pcmd.ElemCount, 1, idxOffset, vertOffset);
+					cmdb.drawIndexed(PrimitiveTopology::kTriangles, pcmd.ElemCount, 1, idxOffset, vertOffset);
 				}
 			}
 			idxOffset += pcmd.ElemCount;
@@ -335,8 +334,8 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 	}
 
 	// Restore state
-	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
-	cmdb->setCullMode(FaceSelectionBit::kBack);
+	cmdb.setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);
+	cmdb.setCullMode(FaceSelectionBit::kBack);
 }
 
 } // end namespace anki

AnKi/Ui/Canvas.h

@@ -63,7 +63,7 @@ public:
 		ImGui::PopFont();
 	}
 
-	void appendToCommandBuffer(CommandBufferPtr cmdb);
+	void appendToCommandBuffer(CommandBuffer& cmdb);
 	/// @}
 
 private:
@@ -87,7 +87,7 @@ private:
 
 	UiList<UiObjectPtr> m_references;
 
-	void appendToCommandBufferInternal(CommandBufferPtr& cmdb);
+	void appendToCommandBufferInternal(CommandBuffer& cmdb);
 };
 /// @}
 

Tests/Ui/Ui.cpp

@@ -127,7 +127,7 @@ ANKI_TEST(Ui, Ui)
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kFramebufferWrite}}, {});
-			canvas->appendToCommandBuffer(cmdb);
+			canvas->appendToCommandBuffer(*cmdb);
 			cmdb->endRenderPass();
 
 			barrier.m_previousUsage = TextureUsageBit::kFramebufferWrite;