Add MDI support plus some refactoring to avoid too many atomic ops

AnKi/Core/App.cpp

@@ -445,7 +445,7 @@ Error App::mainLoop()
 														 || Tracer::getSingleton().getEnabled()
 #endif
 			);
-			ANKI_CHECK(MainRenderer::getSingleton().render(rqueue, presentableTex));
+			ANKI_CHECK(MainRenderer::getSingleton().render(rqueue, presentableTex.get()));
 
 			// Pause and sync async loader. That will force all tasks before the pause to finish in this frame.
 			ResourceManager::getSingleton().getAsyncLoader().pause();

AnKi/Core/GpuMemory/GpuSceneBuffer.cpp

@@ -50,7 +50,7 @@ Error GpuSceneMicroPatcher::init()
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/GpuSceneMicroPatching.ankiprogbin", m_copyProgram));
 	const ShaderProgramResourceVariant* variant;
 	m_copyProgram->getOrCreateVariant(variant);
-	m_grProgram = variant->getProgram();
+	m_grProgram.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -117,11 +117,11 @@ void GpuSceneMicroPatcher::patchGpuScene(CommandBuffer& cmdb)
 	mapped = RebarTransientMemoryPool::getSingleton().allocateFrame(m_crntFramePatchData.getSizeInBytes(), dataToken);
 	memcpy(mapped, &m_crntFramePatchData[0], m_crntFramePatchData.getSizeInBytes());
 
-	cmdb.bindStorageBuffer(0, 0, RebarTransientMemoryPool::getSingleton().getBuffer(), headersToken.m_offset, headersToken.m_range);
-	cmdb.bindStorageBuffer(0, 1, RebarTransientMemoryPool::getSingleton().getBuffer(), dataToken.m_offset, dataToken.m_range);
-	cmdb.bindStorageBuffer(0, 2, GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	cmdb.bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), headersToken.m_offset, headersToken.m_range);
+	cmdb.bindStorageBuffer(0, 1, &RebarTransientMemoryPool::getSingleton().getBuffer(), dataToken.m_offset, dataToken.m_range);
+	cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
-	cmdb.bindShaderProgram(m_grProgram);
+	cmdb.bindShaderProgram(m_grProgram.get());
 
 	const U32 workgroupCountX = m_crntFramePatchHeaders.getSize();
 	cmdb.dispatchCompute(workgroupCountX, 1, 1);

AnKi/Core/GpuMemory/GpuSceneBuffer.h

@@ -91,7 +91,7 @@ public:
 		m_pool.endFrame();
 	}
 
-	const BufferPtr& getBuffer() const
+	Buffer& getBuffer() const
 	{
 		return m_pool.getGpuBuffer();
 	}

AnKi/Core/GpuMemory/RebarTransientMemoryPool.h

@@ -67,9 +67,9 @@ public:
 	/// Allocate staging memory for various operations. The memory will be reclaimed at the begining of the N-(kMaxFramesInFlight-1) frame.
 	void* tryAllocateFrame(PtrSize size, RebarAllocation& token);
 
-	ANKI_PURE const BufferPtr& getBuffer() const
+	ANKI_PURE Buffer& getBuffer() const
 	{
-		return m_buffer;
+		return *m_buffer;
 	}
 
 	U8* getBufferMappedAddress()

AnKi/Core/GpuMemory/UnifiedGeometryBuffer.h

@@ -90,7 +90,7 @@ public:
 		m_pool.endFrame();
 	}
 
-	const BufferPtr& getBuffer() const
+	Buffer& getBuffer() const
 	{
 		return m_pool.getGpuBuffer();
 	}

AnKi/Gr/AccelerationStructure.h

@@ -18,12 +18,12 @@ namespace anki {
 class BottomLevelAccelerationStructureInitInfo
 {
 public:
-	BufferPtr m_indexBuffer;
+	const Buffer* m_indexBuffer = nullptr;
 	PtrSize m_indexBufferOffset = 0;
 	U32 m_indexCount = 0;
 	IndexType m_indexType = IndexType::kCount;
 
-	BufferPtr m_positionBuffer;
+	const Buffer* m_positionBuffer = nullptr;
 	PtrSize m_positionBufferOffset = 0;
 	U32 m_positionStride = 0;
 	Format m_positionsFormat = Format::kNone;
@@ -31,8 +31,8 @@ public:
 
 	Bool isValid() const
 	{
-		if(m_indexBuffer.get() == nullptr || m_indexCount == 0 || m_indexType == IndexType::kCount || m_positionBuffer.get() == nullptr
-		   || m_positionStride == 0 || m_positionsFormat == Format::kNone || m_positionCount == 0)
+		if(m_indexBuffer == nullptr || m_indexCount == 0 || m_indexType == IndexType::kCount || m_positionBuffer == nullptr || m_positionStride == 0
+		   || m_positionsFormat == Format::kNone || m_positionCount == 0)
 		{
 			return false;
 		}

AnKi/Gr/CommandBuffer.h

@@ -73,7 +73,7 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(CommandBufferFlag)
 class CommandBufferInitInfo : public GrBaseInitInfo
 {
 public:
-	FramebufferPtr m_framebuffer; ///< For second level command buffers.
+	Framebuffer* m_framebuffer = nullptr; ///< For second level command buffers.
 	Array<TextureUsageBit, kMaxColorRenderTargets> m_colorAttachmentUsages = {};
 	TextureUsageBit m_depthStencilAttachmentUsage = TextureUsageBit::kNone;
 
@@ -102,13 +102,13 @@ public:
 	/// @{
 
 	/// Bind vertex buffer.
-	void bindVertexBuffer(U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate = VertexStepRate::kVertex);
+	void bindVertexBuffer(U32 binding, Buffer* buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate = VertexStepRate::kVertex);
 
 	/// Setup a vertex attribute.
 	void setVertexAttribute(U32 location, U32 buffBinding, Format fmt, PtrSize relativeOffset);
 
 	/// Bind index buffer.
-	void bindIndexBuffer(const BufferPtr& buff, PtrSize offset, IndexType type);
+	void bindIndexBuffer(Buffer* buff, PtrSize offset, IndexType type);
 
 	/// Enable primitive restart.
 	void setPrimitiveRestart(Bool enable);
@@ -191,21 +191,21 @@ public:
 	/// @param texView The texture view to bind.
 	/// @param sampler The sampler to override the default sampler of the tex.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindTextureAndSampler(U32 set, U32 binding, const TextureViewPtr& texView, const SamplerPtr& sampler, U32 arrayIdx = 0);
+	void bindTextureAndSampler(U32 set, U32 binding, TextureView* texView, Sampler* sampler, U32 arrayIdx = 0);
 
 	/// Bind sampler.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param sampler The sampler to override the default sampler of the tex.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindSampler(U32 set, U32 binding, const SamplerPtr& sampler, U32 arrayIdx = 0);
+	void bindSampler(U32 set, U32 binding, Sampler* sampler, U32 arrayIdx = 0);
 
 	/// Bind a texture.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param texView The texture view to bind.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindTexture(U32 set, U32 binding, const TextureViewPtr& texView, U32 arrayIdx = 0);
+	void bindTexture(U32 set, U32 binding, TextureView* texView, U32 arrayIdx = 0);
 
 	/// Bind uniform buffer.
 	/// @param set The set to bind to.
@@ -215,7 +215,7 @@ public:
 	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end
 	///              of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindUniformBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
+	void bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
 
 	/// Bind storage buffer.
 	/// @param set The set to bind to.
@@ -225,14 +225,14 @@ public:
 	/// @param range The bytes to bind starting from the offset. If it's kMaxPtrSize then map from offset to the end
 	///              of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindStorageBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
+	void bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx = 0);
 
 	/// Bind load/store image.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param img The view to bind.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindImage(U32 set, U32 binding, const TextureViewPtr& img, U32 arrayIdx = 0);
+	void bindImage(U32 set, U32 binding, TextureView* img, U32 arrayIdx = 0);
 
 	/// Bind texture buffer.
 	/// @param set The set to bind to.
@@ -243,14 +243,14 @@ public:
 	///              of the buffer.
 	/// @param fmt The format of the buffer.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindReadOnlyTextureBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx = 0);
+	void bindReadOnlyTextureBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx = 0);
 
 	/// Bind an acceleration structure.
 	/// @param set The set to bind to.
 	/// @param binding The binding to bind to.
 	/// @param[in,out] as The AS to bind.
 	/// @param arrayIdx The array index if the binding is an array.
-	void bindAccelerationStructure(U32 set, U32 binding, const AccelerationStructurePtr& as, U32 arrayIdx = 0);
+	void bindAccelerationStructure(U32 set, U32 binding, AccelerationStructure* as, U32 arrayIdx = 0);
 
 	/// Bind the bindless descriptor set into a slot.
 	void bindAllBindless(U32 set);
@@ -259,12 +259,12 @@ public:
 	void setPushConstants(const void* data, U32 dataSize);
 
 	/// Bind a program.
-	void bindShaderProgram(const ShaderProgramPtr& prog);
+	void bindShaderProgram(ShaderProgram* prog);
 
 	/// Begin renderpass.
 	/// The minx, miny, width, height control the area that the load and store operations will happen. If the scissor is
 	/// bigger than the render area the results are undefined.
-	void beginRenderPass(const FramebufferPtr& fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
+	void beginRenderPass(Framebuffer* fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 						 TextureUsageBit depthStencilAttachmentUsage, U32 minx = 0, U32 miny = 0, U32 width = kMaxU32, U32 height = kMaxU32);
 
 	/// End renderpass.
@@ -276,13 +276,16 @@ public:
 
 	/// @name Jobs
 	/// @{
-	void drawElements(PrimitiveTopology topology, U32 count, U32 instanceCount = 1, U32 firstIndex = 0, U32 baseVertex = 0, U32 baseInstance = 0);
+	void drawIndexed(PrimitiveTopology topology, U32 count, U32 instanceCount = 1, U32 firstIndex = 0, U32 baseVertex = 0, U32 baseInstance = 0);
 
-	void drawArrays(PrimitiveTopology topology, U32 count, U32 instanceCount = 1, U32 first = 0, U32 baseInstance = 0);
+	void draw(PrimitiveTopology topology, U32 count, U32 instanceCount = 1, U32 first = 0, U32 baseInstance = 0);
 
-	void drawElementsIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& indirectBuff);
+	void drawIndexedIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* indirectBuff);
 
-	void drawArraysIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& indirectBuff);
+	void drawIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* indirectBuff);
+
+	void drawIndexedIndirectCount(PrimitiveTopology topology, Buffer* argBuffer, PtrSize argBufferOffset, Buffer* countBuffer,
+								  PtrSize countBufferOffset);
 
 	void dispatchCompute(U32 groupCountX, U32 groupCountY, U32 groupCountZ);
 
@@ -315,48 +318,48 @@ public:
 	/// @param width Width.
 	/// @param height Height.
 	/// @param depth Depth.
-	void traceRays(const BufferPtr& sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize, U32 hitGroupSbtRecordCount, U32 rayTypeCount, U32 width,
-				   U32 height, U32 depth);
+	void traceRays(Buffer* sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize, U32 hitGroupSbtRecordCount, U32 rayTypeCount, U32 width, U32 height,
+				   U32 depth);
 
 	/// Generate mipmaps for non-3D textures. You have to transition all the mip levels of this face and layer to
 	/// TextureUsageBit::kGenerateMipmaps before calling this method.
 	/// @param texView The texture view to generate mips. It should point to a subresource that contains the whole
 	///                mip chain and only one face and one layer.
-	void generateMipmaps2d(const TextureViewPtr& texView);
+	void generateMipmaps2d(TextureView* texView);
 
 	/// Generate mipmaps only for 3D textures.
 	/// @param texView The texture view to generate mips.
-	void generateMipmaps3d(const TextureViewPtr& tex);
+	void generateMipmaps3d(TextureView* tex);
 
 	/// Blit from surface to surface.
 	/// @param srcView The source view that points to a surface.
 	/// @param dstView The destination view that points to a surface.
-	void blitTextureViews(const TextureViewPtr& srcView, const TextureViewPtr& destView);
+	void blitTextureViews(TextureView* srcView, TextureView* destView);
 
 	/// Clear a single texture surface. Can be used for all textures except 3D.
 	/// @param[in,out] texView The texture view to clear.
 	/// @param[in] clearValue The value to clear it with.
-	void clearTextureView(const TextureViewPtr& texView, const ClearValue& clearValue);
+	void clearTextureView(TextureView* texView, const ClearValue& clearValue);
 
 	/// Copy a buffer to a texture surface or volume.
 	/// @param buff The source buffer to copy from.
 	/// @param offset The offset in the buffer to start reading from.
 	/// @param range The size of the buffer to read.
 	/// @param texView The texture view that points to a surface or volume to write to.
-	void copyBufferToTextureView(const BufferPtr& buff, PtrSize offset, PtrSize range, const TextureViewPtr& texView);
+	void copyBufferToTextureView(Buffer* buff, PtrSize offset, PtrSize range, TextureView* texView);
 
 	/// Fill a buffer with some value.
 	/// @param[in,out] buff The buffer to fill.
 	/// @param offset From where to start filling. Must be multiple of 4.
 	/// @param size The bytes to fill. Must be multiple of 4 or kMaxPtrSize to indicate the whole buffer.
 	/// @param value The value to fill the buffer with.
-	void fillBuffer(const BufferPtr& buff, PtrSize offset, PtrSize size, U32 value);
+	void fillBuffer(Buffer* buff, PtrSize offset, PtrSize size, U32 value);
 
 	/// Write the occlusion result to buffer.
 	/// @param[in] queries The queries to write the result of.
 	/// @param offset The offset inside the buffer to write the result.
 	/// @param buff The buffer to update.
-	void writeOcclusionQueriesResultToBuffer(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset, const BufferPtr& buff);
+	void writeOcclusionQueriesResultToBuffer(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset, Buffer* buff);
 
 	/// Copy buffer to buffer.
 	/// @param[in] src Source buffer.
@@ -364,7 +367,7 @@ public:
 	/// @param[out] dst Destination buffer.
 	/// @param dstOffset Offset in the destination buffer.
 	/// @param range Size to copy.
-	void copyBufferToBuffer(const BufferPtr& src, PtrSize srcOffset, const BufferPtr& dst, PtrSize dstOffset, PtrSize range)
+	void copyBufferToBuffer(Buffer* src, PtrSize srcOffset, Buffer* dst, PtrSize dstOffset, PtrSize range)
 	{
 		Array<CopyBufferToBufferInfo, 1> copies = {{{srcOffset, dstOffset, range}}};
 		copyBufferToBuffer(src, dst, copies);
@@ -374,10 +377,10 @@ public:
 	/// @param[in] src Source buffer.
 	/// @param[out] dst Destination buffer.
 	/// @param copies Info on the copies.
-	void copyBufferToBuffer(const BufferPtr& src, const BufferPtr& dst, ConstWeakArray<CopyBufferToBufferInfo> copies);
+	void copyBufferToBuffer(Buffer* src, Buffer* dst, ConstWeakArray<CopyBufferToBufferInfo> copies);
 
 	/// Build the acceleration structure.
-	void buildAccelerationStructure(const AccelerationStructurePtr& as);
+	void buildAccelerationStructure(AccelerationStructure* as);
 
 	/// Do upscaling by an external upscaler
 	/// @param[in] upscaler the upscaler to use for upscaling
@@ -390,9 +393,8 @@ public:
 	/// @param[in] jitterOffset Jittering offset that was applied during the generation of sourceTexture
 	/// @param[in] motionVectorsScale Any scale factor that might need to be applied to the motionVectorsTexture (i.e UV
 	///                               space to Pixel space conversion)
-	void upscale(const GrUpscalerPtr& upscaler, const TextureViewPtr& inColor, const TextureViewPtr& outUpscaledColor,
-				 const TextureViewPtr& motionVectors, const TextureViewPtr& depth, const TextureViewPtr& exposure, const Bool resetAccumulation,
-				 const Vec2& jitterOffset, const Vec2& motionVectorsScale);
+	void upscale(GrUpscaler* upscaler, TextureView* inColor, TextureView* outUpscaledColor, TextureView* motionVectors, TextureView* depth,
+				 TextureView* exposure, Bool resetAccumulation, const Vec2& jitterOffset, const Vec2& motionVectorsScale);
 	/// @}
 
 	/// @name Sync
@@ -408,16 +410,16 @@ public:
 	void resetOcclusionQueries(ConstWeakArray<OcclusionQuery*> queries);
 
 	/// Begin query.
-	void beginOcclusionQuery(const OcclusionQueryPtr& query);
+	void beginOcclusionQuery(OcclusionQuery* query);
 
 	/// End query.
-	void endOcclusionQuery(const OcclusionQueryPtr& query);
+	void endOcclusionQuery(OcclusionQuery* query);
 
 	/// Reset timestamp queries before writeTimestamp.
 	void resetTimestampQueries(ConstWeakArray<TimestampQuery*> queries);
 
 	/// Write a timestamp.
-	void writeTimestamp(const TimestampQueryPtr& query);
+	void writeTimestamp(TimestampQuery* query);
 
 	/// Append second level command buffers.
 	void pushSecondLevelCommandBuffers(ConstWeakArray<CommandBuffer*> cmdbs);

AnKi/Gr/Common.h

@@ -182,6 +182,9 @@ public:
 	/// Min size of a texel in the shading rate image.
 	U32 m_minShadingRateImageTexelSize = 0;
 
+	/// The max number of drawcalls in draw indirect count calls.
+	U32 m_maxDrawIndirectCount = 0;
+
 	/// GPU vendor.
 	GpuVendor m_gpuVendor = GpuVendor::kUnknown;
 

AnKi/Gr/RenderGraph.cpp

@@ -121,12 +121,13 @@ public:
 	Function<void(RenderPassWorkContext&), MemoryPoolPtrWrapper<StackMemoryPool>> m_callback;
 
 	DynamicArray<CommandBufferPtr, MemoryPoolPtrWrapper<StackMemoryPool>> m_secondLevelCmdbs;
-	/// Will reuse the m_secondLevelCmdbInitInfo.m_framebuffer to get the framebuffer.
 	CommandBufferInitInfo m_secondLevelCmdbInitInfo;
 	Array<U32, 4> m_fbRenderArea;
 	Array<TextureUsageBit, kMaxColorRenderTargets> m_colorUsages = {}; ///< For beginRender pass
 	TextureUsageBit m_dsUsage = TextureUsageBit::kNone; ///< For beginRender pass
 
+	FramebufferPtr m_framebuffer;
+
 	U32 m_batchIdx ANKI_DEBUG_CODE(= kMaxU32);
 	Bool m_drawsToPresentable = false;
 
@@ -136,16 +137,6 @@ public:
 		, m_secondLevelCmdbs(pool)
 	{
 	}
-
-	FramebufferPtr& fb()
-	{
-		return m_secondLevelCmdbInitInfo.m_framebuffer;
-	}
-
-	const FramebufferPtr& fb() const
-	{
-		return m_secondLevelCmdbInitInfo.m_framebuffer;
-	}
 };
 
 /// A batch of render passes. These passes can run in parallel.
@@ -365,7 +356,7 @@ void RenderGraph::reset()
 
 	for(Pass& p : m_ctx->m_passes)
 	{
-		p.fb().reset(nullptr);
+		p.m_framebuffer.reset(nullptr);
 		p.m_secondLevelCmdbs.destroy();
 		p.m_callback.destroy();
 	}
@@ -479,7 +470,8 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 			outAtt.m_storeOperation = inAtt.m_storeOperation;
 
 			// Create texture view
-			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[i].m_idx].m_texture, TextureSubresourceInfo(inAtt.m_surface), "RenderGraph");
+			const TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[i].m_idx].m_texture.get(), TextureSubresourceInfo(inAtt.m_surface),
+											   "RenderGraph");
 			TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
 
 			outAtt.m_textureView = std::move(view);
@@ -497,8 +489,8 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 			outAtt.m_stencilStoreOperation = inAtt.m_stencilStoreOperation;
 
 			// Create texture view
-			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[kMaxColorRenderTargets].m_idx].m_texture,
-										 TextureSubresourceInfo(inAtt.m_surface, inAtt.m_aspect), "RenderGraph");
+			const TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[kMaxColorRenderTargets].m_idx].m_texture.get(),
+											   TextureSubresourceInfo(inAtt.m_surface, inAtt.m_aspect), "RenderGraph");
 			TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
 
 			outAtt.m_textureView = std::move(view);
@@ -506,8 +498,8 @@ FramebufferPtr RenderGraph::getOrCreateFramebuffer(const FramebufferDescription&
 
 		if(fbDescr.m_shadingRateAttachmentTexelWidth > 0)
 		{
-			TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[kMaxColorRenderTargets + 1].m_idx].m_texture, fbDescr.m_shadingRateAttachmentSurface,
-										 "RenderGraph SRI");
+			const TextureViewInitInfo viewInit(m_ctx->m_rts[rtHandles[kMaxColorRenderTargets + 1].m_idx].m_texture.get(),
+											   fbDescr.m_shadingRateAttachmentSurface, "RenderGraph SRI");
 			TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
 
 			fbInit.m_shadingRateImage.m_texelWidth = fbDescr.m_shadingRateAttachmentTexelWidth;
@@ -817,7 +809,8 @@ void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphDescription& descr
 			if(graphicsPass.hasFramebuffer())
 			{
 				Bool drawsToPresentable;
-				outPass.fb() = getOrCreateFramebuffer(graphicsPass.m_fbDescr, &graphicsPass.m_rtHandles[0], inPass.m_name.cstr(), drawsToPresentable);
+				outPass.m_framebuffer =
+					getOrCreateFramebuffer(graphicsPass.m_fbDescr, &graphicsPass.m_rtHandles[0], inPass.m_name.cstr(), drawsToPresentable);
 
 				outPass.m_fbRenderArea = graphicsPass.m_fbRenderArea;
 				outPass.m_drawsToPresentable = drawsToPresentable;
@@ -874,8 +867,8 @@ void RenderGraph::initBatches()
 		}
 
 		// Get or create cmdb for the batch.
-		// Create a new cmdb if the batch is writing to swapchain. This will help Vulkan to have a dependency of the
-		// swap chain image acquire to the 2nd command buffer instead of adding it to a single big cmdb.
+		// Create a new cmdb if the batch is writing to swapchain. This will help Vulkan to have a dependency of the swap chain image acquire to the
+		// 2nd command buffer instead of adding it to a single big cmdb.
 		if(m_ctx->m_graphicsCmdbs.isEmpty() || drawsToPresentable)
 		{
 			CommandBufferInitInfo cmdbInit;
@@ -893,7 +886,7 @@ void RenderGraph::initBatches()
 				TimestampQueryPtr query = GrManager::getSingleton().newTimestampQuery();
 				TimestampQuery* pQuery = query.get();
 				cmdb->resetTimestampQueries({&pQuery, 1});
-				cmdb->writeTimestamp(query);
+				cmdb->writeTimestamp(query.get());
 
 				m_statistics.m_nextTimestamp = (m_statistics.m_nextTimestamp + 1) % kMaxBufferedTimestamps;
 				m_statistics.m_timestamps[m_statistics.m_nextTimestamp * 2] = query;
@@ -957,7 +950,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 					outPass.m_secondLevelCmdbs.resize(inPass.m_secondLevelCmdbsCount);
 					CommandBufferInitInfo& cmdbInit = outPass.m_secondLevelCmdbInitInfo;
 					cmdbInit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSecondLevel;
-					ANKI_ASSERT(cmdbInit.m_framebuffer.isCreated());
+					cmdbInit.m_framebuffer = outPass.m_framebuffer.get();
 					cmdbInit.m_colorAttachmentUsages = outPass.m_colorUsages;
 					cmdbInit.m_depthStencilAttachmentUsage = outPass.m_dsUsage;
 				}
@@ -975,7 +968,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 }
 
 template<typename TFunc>
-void RenderGraph::iterateSurfsOrVolumes(const TexturePtr& tex, const TextureSubresourceInfo& subresource, TFunc func)
+void RenderGraph::iterateSurfsOrVolumes(const Texture& tex, const TextureSubresourceInfo& subresource, TFunc func)
 {
 	for(U32 mip = subresource.m_firstMipmap; mip < subresource.m_firstMipmap + subresource.m_mipmapCount; ++mip)
 	{
@@ -984,8 +977,8 @@ void RenderGraph::iterateSurfsOrVolumes(const TexturePtr& tex, const TextureSubr
 			for(U32 face = subresource.m_firstFace; face < U32(subresource.m_firstFace + subresource.m_faceCount); ++face)
 			{
 				// Compute surf or vol idx
-				const U32 faceCount = textureTypeIsCube(tex->getTextureType()) ? 6 : 1;
-				const U32 idx = (faceCount * tex->getLayerCount()) * mip + faceCount * layer + face;
+				const U32 faceCount = textureTypeIsCube(tex.getTextureType()) ? 6 : 1;
+				const U32 idx = (faceCount * tex.getLayerCount()) * mip + faceCount * layer + face;
 				const TextureSurfaceInfo surf(mip, 0, face, layer);
 
 				if(!func(idx, surf))
@@ -1007,7 +1000,7 @@ void RenderGraph::setTextureBarrier(Batch& batch, const RenderPassDependency& de
 	const TextureUsageBit depUsage = dep.m_texture.m_usage;
 	RT& rt = ctx.m_rts[rtIdx];
 
-	iterateSurfsOrVolumes(rt.m_texture, dep.m_texture.m_subresource, [&](U32 surfOrVolIdx, const TextureSurfaceInfo& surf) {
+	iterateSurfsOrVolumes(*rt.m_texture, dep.m_texture.m_subresource, [&](U32 surfOrVolIdx, const TextureSurfaceInfo& surf) {
 		TextureUsageBit& crntUsage = rt.m_surfOrVolUsages[surfOrVolIdx];
 		if(crntUsage != depUsage)
 		{
@@ -1226,10 +1219,10 @@ void RenderGraph::compileNewGraph(const RenderGraphDescription& descr, StackMemo
 #endif
 }
 
-TexturePtr RenderGraph::getTexture(RenderTargetHandle handle) const
+Texture& RenderGraph::getTexture(RenderTargetHandle handle) const
 {
 	ANKI_ASSERT(m_ctx->m_rts[handle.m_idx].m_texture.isCreated());
-	return m_ctx->m_rts[handle.m_idx].m_texture;
+	return *m_ctx->m_rts[handle.m_idx].m_texture;
 }
 
 void RenderGraph::getCachedBuffer(BufferHandle handle, Buffer*& buff, PtrSize& offset, PtrSize& range) const
@@ -1240,10 +1233,10 @@ void RenderGraph::getCachedBuffer(BufferHandle handle, Buffer*& buff, PtrSize& o
 	range = record.m_range;
 }
 
-AccelerationStructurePtr RenderGraph::getAs(AccelerationStructureHandle handle) const
+AccelerationStructure* RenderGraph::getAs(AccelerationStructureHandle handle) const
 {
 	ANKI_ASSERT(m_ctx->m_as[handle.m_idx].m_as.isCreated());
-	return m_ctx->m_as[handle.m_idx].m_as;
+	return m_ctx->m_as[handle.m_idx].m_as.get();
 }
 
 void RenderGraph::runSecondLevel(U32 threadIdx)
@@ -1335,9 +1328,9 @@ void RenderGraph::run() const
 		{
 			const Pass& pass = m_ctx->m_passes[passIdx];
 
-			if(pass.fb().isCreated())
+			if(pass.m_framebuffer)
 			{
-				cmdb->beginRenderPass(pass.fb(), pass.m_colorUsages, pass.m_dsUsage, pass.m_fbRenderArea[0], pass.m_fbRenderArea[1],
+				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]);
 			}
 
@@ -1361,7 +1354,7 @@ void RenderGraph::run() const
 				cmdb->pushSecondLevelCommandBuffers(cmdbs);
 			}
 
-			if(pass.fb().isCreated())
+			if(pass.m_framebuffer)
 			{
 				cmdb->endRenderPass();
 			}
@@ -1382,7 +1375,7 @@ void RenderGraph::flush()
 			TimestampQueryPtr query = GrManager::getSingleton().newTimestampQuery();
 			TimestampQuery* pQuery = query.get();
 			m_ctx->m_graphicsCmdbs[i]->resetTimestampQueries({&pQuery, 1});
-			m_ctx->m_graphicsCmdbs[i]->writeTimestamp(query);
+			m_ctx->m_graphicsCmdbs[i]->writeTimestamp(pQuery);
 
 			m_statistics.m_timestamps[m_statistics.m_nextTimestamp * 2 + 1] = query;
 			m_statistics.m_cpuStartTimes[m_statistics.m_nextTimestamp] = HighRezTimer::getCurrentTime();

AnKi/Gr/RenderGraph.h

@@ -123,80 +123,80 @@ public:
 
 	void getBufferState(BufferHandle handle, Buffer*& buff, PtrSize& offset, PtrSize& range) const;
 
-	void getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceInfo& subresource, TexturePtr& tex) const;
+	void getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceInfo& subresource, Texture*& tex) const;
 
 	/// Create a whole texture view from a handle
 	TextureViewPtr createTextureView(RenderTargetHandle handle)
 	{
-		TexturePtr tex = getTexture(handle);
+		Texture* tex = &getTexture(handle);
 		TextureViewInitInfo viewInit(tex, "TmpRenderGraph"); // Use the whole texture
 		getRenderTargetState(handle, viewInit, tex);
 		return GrManager::getSingleton().newTextureView(viewInit);
 	}
 
 	/// Convenience method.
-	void bindTextureAndSampler(U32 set, U32 binding, RenderTargetHandle handle, const TextureSubresourceInfo& subresource, const SamplerPtr& sampler)
+	void bindTextureAndSampler(U32 set, U32 binding, RenderTargetHandle handle, const TextureSubresourceInfo& subresource, Sampler* sampler)
 	{
-		TexturePtr tex;
+		Texture* tex;
 		getRenderTargetState(handle, subresource, tex);
 		TextureViewInitInfo viewInit(tex, subresource, "TmpRenderGraph");
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindTextureAndSampler(set, binding, view, sampler);
+		m_commandBuffer->bindTextureAndSampler(set, binding, view.get(), sampler);
 	}
 
 	/// Convenience method.
 	void bindTexture(U32 set, U32 binding, RenderTargetHandle handle, const TextureSubresourceInfo& subresource)
 	{
-		TexturePtr tex;
+		Texture* tex;
 		getRenderTargetState(handle, subresource, tex);
 		TextureViewInitInfo viewInit(tex, subresource, "TmpRenderGraph");
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindTexture(set, binding, view);
+		m_commandBuffer->bindTexture(set, binding, view.get());
 	}
 
 	/// Convenience method to bind the whole texture as color.
-	void bindColorTextureAndSampler(U32 set, U32 binding, RenderTargetHandle handle, const SamplerPtr& sampler)
+	void bindColorTextureAndSampler(U32 set, U32 binding, RenderTargetHandle handle, Sampler* sampler)
 	{
-		TexturePtr tex = getTexture(handle);
+		Texture* tex = &getTexture(handle);
 		TextureViewInitInfo viewInit(tex); // Use the whole texture
 		getRenderTargetState(handle, viewInit, tex);
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindTextureAndSampler(set, binding, view, sampler);
+		m_commandBuffer->bindTextureAndSampler(set, binding, view.get(), sampler);
 	}
 
 	/// Convenience method to bind the whole texture as color.
 	void bindColorTexture(U32 set, U32 binding, RenderTargetHandle handle, U32 arrayIdx = 0)
 	{
-		TexturePtr tex = getTexture(handle);
+		Texture* tex = &getTexture(handle);
 		TextureViewInitInfo viewInit(tex); // Use the whole texture
 		getRenderTargetState(handle, viewInit, tex);
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindTexture(set, binding, view, arrayIdx);
+		m_commandBuffer->bindTexture(set, binding, view.get(), arrayIdx);
 	}
 
 	/// Convenience method.
 	void bindImage(U32 set, U32 binding, RenderTargetHandle handle, const TextureSubresourceInfo& subresource, U32 arrayIdx = 0)
 	{
-		TexturePtr tex;
+		Texture* tex;
 		getRenderTargetState(handle, subresource, tex);
 		TextureViewInitInfo viewInit(tex, subresource, "TmpRenderGraph");
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindImage(set, binding, view, arrayIdx);
+		m_commandBuffer->bindImage(set, binding, view.get(), arrayIdx);
 	}
 
 	/// Convenience method to bind the whole image.
 	void bindImage(U32 set, U32 binding, RenderTargetHandle handle, U32 arrayIdx = 0)
 	{
-		TexturePtr tex;
+		Texture* tex;
 #if ANKI_ENABLE_ASSERTIONS
-		tex = getTexture(handle);
+		tex = &getTexture(handle);
 		ANKI_ASSERT(tex->getLayerCount() == 1 && tex->getMipmapCount() == 1 && tex->getDepthStencilAspect() == DepthStencilAspectBit::kNone);
 #endif
 		const TextureSubresourceInfo subresource;
 		getRenderTargetState(handle, subresource, tex);
 		TextureViewInitInfo viewInit(tex, subresource, "TmpRenderGraph");
 		TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
-		m_commandBuffer->bindImage(set, binding, view, arrayIdx);
+		m_commandBuffer->bindImage(set, binding, view.get(), arrayIdx);
 	}
 
 	/// Convenience method.
@@ -205,7 +205,7 @@ public:
 		Buffer* buff;
 		PtrSize offset, range;
 		getBufferState(handle, buff, offset, range);
-		m_commandBuffer->bindStorageBuffer(set, binding, BufferPtr(buff), offset, range);
+		m_commandBuffer->bindStorageBuffer(set, binding, buff, offset, range);
 	}
 
 	/// Convenience method.
@@ -214,7 +214,7 @@ public:
 		Buffer* buff;
 		PtrSize offset, range;
 		getBufferState(handle, buff, offset, range);
-		m_commandBuffer->bindUniformBuffer(set, binding, BufferPtr(buff), offset, range);
+		m_commandBuffer->bindUniformBuffer(set, binding, buff, offset, range);
 	}
 
 	/// Convenience method.
@@ -225,7 +225,7 @@ private:
 	U32 m_passIdx ANKI_DEBUG_CODE(= kMaxU32);
 	U32 m_batchIdx ANKI_DEBUG_CODE(= kMaxU32);
 
-	TexturePtr getTexture(RenderTargetHandle handle) const;
+	Texture& getTexture(RenderTargetHandle handle) const;
 };
 
 /// RenderGraph pass dependency.
@@ -512,20 +512,19 @@ public:
 	ComputeRenderPassDescription& newComputeRenderPass(CString name);
 
 	/// Import an existing render target and let the render graph know about it's up-to-date usage.
-	RenderTargetHandle importRenderTarget(TexturePtr tex, TextureUsageBit usage);
+	RenderTargetHandle importRenderTarget(Texture* tex, TextureUsageBit usage);
 
-	/// Import an existing render target and let the render graph find it's current usage by looking at the previous
-	/// frame.
-	RenderTargetHandle importRenderTarget(TexturePtr tex);
+	/// Import an existing render target and let the render graph find it's current usage by looking at the previous frame.
+	RenderTargetHandle importRenderTarget(Texture* tex);
 
 	/// Get or create a new render target.
 	RenderTargetHandle newRenderTarget(const RenderTargetDescription& initInf);
 
 	/// Import a buffer.
-	BufferHandle importBuffer(BufferPtr buff, BufferUsageBit usage, PtrSize offset = 0, PtrSize range = kMaxPtrSize);
+	BufferHandle importBuffer(Buffer* buff, BufferUsageBit usage, PtrSize offset = 0, PtrSize range = kMaxPtrSize);
 
 	/// Import an AS.
-	AccelerationStructureHandle importAccelerationStructure(AccelerationStructurePtr as, AccelerationStructureUsageBit usage);
+	AccelerationStructureHandle importAccelerationStructure(AccelerationStructure* as, AccelerationStructureUsageBit usage);
 
 	/// Gather statistics.
 	void setStatisticsEnabled(Bool gather)
@@ -559,7 +558,7 @@ private:
 		Bool m_importedAndUndefinedUsage = false;
 	};
 
-	class Buffer : public Resource
+	class BufferRsrc : public Resource
 	{
 	public:
 		BufferUsageBit m_usage;
@@ -578,7 +577,7 @@ private:
 	StackMemoryPool* m_pool = nullptr;
 	DynamicArray<RenderPassDescriptionBase*, MemoryPoolPtrWrapper<StackMemoryPool>> m_passes{m_pool};
 	DynamicArray<RT, MemoryPoolPtrWrapper<StackMemoryPool>> m_renderTargets{m_pool};
-	DynamicArray<Buffer, MemoryPoolPtrWrapper<StackMemoryPool>> m_buffers{m_pool};
+	DynamicArray<BufferRsrc, MemoryPoolPtrWrapper<StackMemoryPool>> m_buffers{m_pool};
 	DynamicArray<AS, MemoryPoolPtrWrapper<StackMemoryPool>> m_as{m_pool};
 	Bool m_gatherStatistics = false;
 
@@ -740,7 +739,7 @@ private:
 	void setTextureBarrier(Batch& batch, const RenderPassDependency& consumer);
 
 	template<typename TFunc>
-	static void iterateSurfsOrVolumes(const TexturePtr& tex, const TextureSubresourceInfo& subresource, TFunc func);
+	static void iterateSurfsOrVolumes(const Texture& tex, const TextureSubresourceInfo& subresource, TFunc func);
 
 	void getCrntUsage(RenderTargetHandle handle, U32 batchIdx, const TextureSubresourceInfo& subresource, TextureUsageBit& usage) const;
 
@@ -752,9 +751,9 @@ private:
 	static GrString asUsageToStr(StackMemoryPool& pool, AccelerationStructureUsageBit usage);
 	/// @}
 
-	TexturePtr getTexture(RenderTargetHandle handle) const;
+	Texture& getTexture(RenderTargetHandle handle) const;
 	void getCachedBuffer(BufferHandle handle, Buffer*& buff, PtrSize& offset, PtrSize& range) const;
-	AccelerationStructurePtr getAs(AccelerationStructureHandle handle) const;
+	AccelerationStructure* getAs(AccelerationStructureHandle handle) const;
 };
 /// @}
 

AnKi/Gr/RenderGraph.inl.h

@@ -17,14 +17,14 @@ inline void RenderPassWorkContext::getBufferState(BufferHandle handle, Buffer*&
 	m_rgraph->getCachedBuffer(handle, buff, offset, range);
 }
 
-inline void RenderPassWorkContext::getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceInfo& subresource, TexturePtr& tex) const
+inline void RenderPassWorkContext::getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceInfo& subresource, Texture*& tex) const
 {
 	TextureUsageBit usage;
 	m_rgraph->getCrntUsage(handle, m_batchIdx, subresource, usage);
-	tex = m_rgraph->getTexture(handle);
+	tex = &m_rgraph->getTexture(handle);
 }
 
-inline TexturePtr RenderPassWorkContext::getTexture(RenderTargetHandle handle) const
+inline Texture& RenderPassWorkContext::getTexture(RenderTargetHandle handle) const
 {
 	return m_rgraph->getTexture(handle);
 }
@@ -270,15 +270,15 @@ inline ComputeRenderPassDescription& RenderGraphDescription::newComputeRenderPas
 	return *pass;
 }
 
-inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr tex, TextureUsageBit usage)
+inline RenderTargetHandle RenderGraphDescription::importRenderTarget(Texture* tex, TextureUsageBit usage)
 {
 	for([[maybe_unused]] const RT& rt : m_renderTargets)
 	{
-		ANKI_ASSERT(rt.m_importedTex != tex && "Already imported");
+		ANKI_ASSERT(rt.m_importedTex.tryGet() != tex && "Already imported");
 	}
 
 	RT& rt = *m_renderTargets.emplaceBack();
-	rt.m_importedTex = tex;
+	rt.m_importedTex.reset(tex);
 	rt.m_importedLastKnownUsage = usage;
 	rt.m_usageDerivedByDeps = TextureUsageBit::kNone;
 	rt.setName(tex->getName());
@@ -288,7 +288,7 @@ inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr
 	return out;
 }
 
-inline RenderTargetHandle RenderGraphDescription::importRenderTarget(TexturePtr tex)
+inline RenderTargetHandle RenderGraphDescription::importRenderTarget(Texture* tex)
 {
 	RenderTargetHandle out = importRenderTarget(tex, TextureUsageBit::kNone);
 	m_renderTargets.getBack().m_importedAndUndefinedUsage = true;
@@ -311,7 +311,7 @@ inline RenderTargetHandle RenderGraphDescription::newRenderTarget(const RenderTa
 	return out;
 }
 
-inline BufferHandle RenderGraphDescription::importBuffer(BufferPtr buff, BufferUsageBit usage, PtrSize offset, PtrSize range)
+inline BufferHandle RenderGraphDescription::importBuffer(Buffer* buff, BufferUsageBit usage, PtrSize offset, PtrSize range)
 {
 	// Checks
 	if(range == kMaxPtrSize)
@@ -325,15 +325,15 @@ inline BufferHandle RenderGraphDescription::importBuffer(BufferPtr buff, BufferU
 
 	ANKI_ASSERT(range > 0);
 
-	for([[maybe_unused]] const Buffer& bb : m_buffers)
+	for([[maybe_unused]] const BufferRsrc& bb : m_buffers)
 	{
-		ANKI_ASSERT((bb.m_importedBuff != buff || !bufferRangeOverlaps(bb.m_offset, bb.m_range, offset, range)) && "Range already imported");
+		ANKI_ASSERT((bb.m_importedBuff.get() != buff || !bufferRangeOverlaps(bb.m_offset, bb.m_range, offset, range)) && "Range already imported");
 	}
 
-	Buffer& b = *m_buffers.emplaceBack();
+	BufferRsrc& b = *m_buffers.emplaceBack();
 	b.setName(buff->getName());
 	b.m_usage = usage;
-	b.m_importedBuff = std::move(buff);
+	b.m_importedBuff.reset(buff);
 	b.m_offset = offset;
 	b.m_range = range;
 
@@ -342,17 +342,16 @@ inline BufferHandle RenderGraphDescription::importBuffer(BufferPtr buff, BufferU
 	return out;
 }
 
-inline AccelerationStructureHandle RenderGraphDescription::importAccelerationStructure(AccelerationStructurePtr as,
-																					   AccelerationStructureUsageBit usage)
+inline AccelerationStructureHandle RenderGraphDescription::importAccelerationStructure(AccelerationStructure* as, AccelerationStructureUsageBit usage)
 {
 	for([[maybe_unused]] const AS& a : m_as)
 	{
-		ANKI_ASSERT(a.m_importedAs != as && "Already imported");
+		ANKI_ASSERT(a.m_importedAs.get() != as && "Already imported");
 	}
 
 	AS& a = *m_as.emplaceBack();
 	a.setName(as->getName());
-	a.m_importedAs = std::move(as);
+	a.m_importedAs.reset(as);
 	a.m_usage = usage;
 
 	AccelerationStructureHandle handle;

AnKi/Gr/ShaderProgram.cpp

@@ -43,7 +43,7 @@ Bool ShaderProgramInitInfo::isValid() const
 	}
 
 	ShaderTypeBit rtMask = ShaderTypeBit::kNone;
-	for(const ShaderPtr& s : m_rayTracingShaders.m_rayGenShaders)
+	for(const Shader* s : m_rayTracingShaders.m_rayGenShaders)
 	{
 		if(s->getShaderType() != ShaderType::kRayGen)
 		{
@@ -52,7 +52,7 @@ Bool ShaderProgramInitInfo::isValid() const
 		rtMask |= ShaderTypeBit::kRayGen;
 	}
 
-	for(const ShaderPtr& s : m_rayTracingShaders.m_missShaders)
+	for(const Shader* s : m_rayTracingShaders.m_missShaders)
 	{
 		if(s->getShaderType() != ShaderType::kMiss)
 		{

AnKi/Gr/ShaderProgram.h

@@ -17,16 +17,16 @@ namespace anki {
 class RayTracingHitGroup
 {
 public:
-	ShaderPtr m_closestHitShader;
-	ShaderPtr m_anyHitShader;
+	Shader* m_closestHitShader = nullptr;
+	Shader* m_anyHitShader = nullptr;
 };
 
 /// @memberof ShaderProgramInitInfo
 class RayTracingShaders
 {
 public:
-	WeakArray<ShaderPtr> m_rayGenShaders;
-	WeakArray<ShaderPtr> m_missShaders;
+	WeakArray<Shader*> m_rayGenShaders;
+	WeakArray<Shader*> m_missShaders;
 	WeakArray<RayTracingHitGroup> m_hitGroups;
 	U32 m_maxRecursionDepth = 1;
 };
@@ -36,10 +36,10 @@ class ShaderProgramInitInfo : public GrBaseInitInfo
 {
 public:
 	/// Option 1
-	Array<ShaderPtr, U32(ShaderType::kLastGraphics + 1)> m_graphicsShaders;
+	Array<Shader*, U32(ShaderType::kLastGraphics + 1)> m_graphicsShaders = {};
 
 	/// Option 2
-	ShaderPtr m_computeShader;
+	Shader* m_computeShader = nullptr;
 
 	/// Option 3
 	RayTracingShaders m_rayTracingShaders;

AnKi/Gr/TextureView.h

@@ -17,9 +17,9 @@ namespace anki {
 class TextureViewInitInfo : public GrBaseInitInfo, public TextureSubresourceInfo
 {
 public:
-	TexturePtr m_texture;
+	Texture* m_texture = nullptr;
 
-	TextureViewInitInfo(TexturePtr tex, CString name = {})
+	TextureViewInitInfo(Texture* tex, CString name = {})
 		: GrBaseInitInfo(name)
 		, m_texture(tex)
 	{
@@ -38,8 +38,7 @@ public:
 	{
 	}
 
-	TextureViewInitInfo(TexturePtr tex, const TextureSurfaceInfo& surf, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone,
-						CString name = {})
+	TextureViewInitInfo(Texture* tex, const TextureSurfaceInfo& surf, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone, CString name = {})
 		: GrBaseInitInfo(name)
 		, m_texture(tex)
 	{
@@ -53,7 +52,7 @@ public:
 		ANKI_ASSERT(isValid());
 	}
 
-	TextureViewInitInfo(TexturePtr tex, const TextureSubresourceInfo& subresource, CString name = {})
+	TextureViewInitInfo(Texture* tex, const TextureSubresourceInfo& subresource, CString name = {})
 		: GrBaseInitInfo(name)
 		, m_texture(tex)
 	{
@@ -63,7 +62,7 @@ public:
 
 	Bool isValid() const
 	{
-		return m_texture.isCreated() && m_texture->isSubresourceValid(*this);
+		return m_texture != nullptr && m_texture->isSubresourceValid(*this);
 	}
 };
 

AnKi/Gr/Utils/SegregatedListsGpuMemoryPool.cpp

@@ -152,7 +152,7 @@ Error SegregatedListsGpuMemoryPool::allocateChunk(Chunk*& newChunk, PtrSize& chu
 		barriers[1].m_nextUsage = BufferUsageBit::kTransferDestination;
 		cmdb->setPipelineBarrier({}, barriers, {});
 
-		cmdb->copyBufferToBuffer(m_gpuBuffer, 0, newBuffer, 0, m_gpuBuffer->getSize());
+		cmdb->copyBufferToBuffer(m_gpuBuffer.get(), 0, newBuffer.get(), 0, m_gpuBuffer->getSize());
 
 		barriers[1].m_previousUsage = BufferUsageBit::kTransferDestination;
 		barriers[1].m_nextUsage = m_bufferUsage;

AnKi/Gr/Utils/SegregatedListsGpuMemoryPool.h

@@ -74,10 +74,10 @@ public:
 
 	/// Need to be checking this constantly to get the updated buffer in case of CoWs.
 	/// @note It's not thread-safe.
-	const BufferPtr& getGpuBuffer() const
+	Buffer& getGpuBuffer() const
 	{
 		ANKI_ASSERT(m_gpuBuffer.isCreated() && "The buffer hasn't been created yet");
-		return m_gpuBuffer;
+		return *m_gpuBuffer;
 	}
 
 	/// @note It's thread-safe.

AnKi/Gr/Vulkan/CommandBuffer.cpp

@@ -56,7 +56,7 @@ void CommandBuffer::flush(ConstWeakArray<FencePtr> waitFences, FencePtr* signalF
 	}
 }
 
-void CommandBuffer::bindVertexBuffer(U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate)
+void CommandBuffer::bindVertexBuffer(U32 binding, Buffer* buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindVertexBufferInternal(binding, buff, offset, stride, stepRate);
@@ -68,7 +68,7 @@ void CommandBuffer::setVertexAttribute(U32 location, U32 buffBinding, Format fmt
 	self.setVertexAttributeInternal(location, buffBinding, fmt, relativeOffset);
 }
 
-void CommandBuffer::bindIndexBuffer(const BufferPtr& buff, PtrSize offset, IndexType type)
+void CommandBuffer::bindIndexBuffer(Buffer* buff, PtrSize offset, IndexType type)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindIndexBufferInternal(buff, offset, type);
@@ -177,49 +177,49 @@ void CommandBuffer::setBlendOperation(U32 attachment, BlendOperation funcRgb, Bl
 	self.setBlendOperationInternal(attachment, funcRgb, funcA);
 }
 
-void CommandBuffer::bindTextureAndSampler(U32 set, U32 binding, const TextureViewPtr& texView, const SamplerPtr& sampler, U32 arrayIdx)
+void CommandBuffer::bindTextureAndSampler(U32 set, U32 binding, TextureView* texView, Sampler* sampler, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindTextureAndSamplerInternal(set, binding, texView, sampler, arrayIdx);
 }
 
-void CommandBuffer::bindTexture(U32 set, U32 binding, const TextureViewPtr& texView, U32 arrayIdx)
+void CommandBuffer::bindTexture(U32 set, U32 binding, TextureView* texView, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindTextureInternal(set, binding, texView, arrayIdx);
 }
 
-void CommandBuffer::bindSampler(U32 set, U32 binding, const SamplerPtr& sampler, U32 arrayIdx)
+void CommandBuffer::bindSampler(U32 set, U32 binding, Sampler* sampler, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindSamplerInternal(set, binding, sampler, arrayIdx);
 }
 
-void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindUniformBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindUniformBufferInternal(set, binding, buff, offset, range, arrayIdx);
 }
 
-void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+void CommandBuffer::bindStorageBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindStorageBufferInternal(set, binding, buff, offset, range, arrayIdx);
 }
 
-void CommandBuffer::bindImage(U32 set, U32 binding, const TextureViewPtr& img, U32 arrayIdx)
+void CommandBuffer::bindImage(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindImageInternal(set, binding, img, arrayIdx);
 }
 
-void CommandBuffer::bindAccelerationStructure(U32 set, U32 binding, const AccelerationStructurePtr& as, U32 arrayIdx)
+void CommandBuffer::bindAccelerationStructure(U32 set, U32 binding, AccelerationStructure* as, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindAccelerationStructureInternal(set, binding, as, arrayIdx);
 }
 
-void CommandBuffer::bindReadOnlyTextureBuffer(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
+void CommandBuffer::bindReadOnlyTextureBuffer(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindReadOnlyTextureBufferInternal(set, binding, buff, offset, range, fmt, arrayIdx);
@@ -231,13 +231,13 @@ void CommandBuffer::bindAllBindless(U32 set)
 	self.bindAllBindlessInternal(set);
 }
 
-void CommandBuffer::bindShaderProgram(const ShaderProgramPtr& prog)
+void CommandBuffer::bindShaderProgram(ShaderProgram* prog)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.bindShaderProgramInternal(prog);
 }
 
-void CommandBuffer::beginRenderPass(const FramebufferPtr& fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
+void CommandBuffer::beginRenderPass(Framebuffer* fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 									TextureUsageBit depthStencilAttachmentUsage, U32 minx, U32 miny, U32 width, U32 height)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
@@ -256,28 +256,35 @@ void CommandBuffer::setVrsRate(VrsRate rate)
 	self.setVrsRateInternal(rate);
 }
 
-void CommandBuffer::drawElements(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 firstIndex, U32 baseVertex, U32 baseInstance)
+void CommandBuffer::drawIndexed(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 firstIndex, U32 baseVertex, U32 baseInstance)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.drawElementsInternal(topology, count, instanceCount, firstIndex, baseVertex, baseInstance);
+	self.drawIndexedInternal(topology, count, instanceCount, firstIndex, baseVertex, baseInstance);
 }
 
-void CommandBuffer::drawArrays(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
+void CommandBuffer::draw(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.drawArraysInternal(topology, count, instanceCount, first, baseInstance);
+	self.drawInternal(topology, count, instanceCount, first, baseInstance);
 }
 
-void CommandBuffer::drawArraysIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& buff)
+void CommandBuffer::drawIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* buff)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.drawArraysIndirectInternal(topology, drawCount, offset, buff);
+	self.drawIndirectInternal(topology, drawCount, offset, buff);
 }
 
-void CommandBuffer::drawElementsIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& buff)
+void CommandBuffer::drawIndexedIndirectCount(PrimitiveTopology topology, Buffer* argBuffer, PtrSize argBufferOffset, Buffer* countBuffer,
+											 PtrSize countBufferOffset)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
-	self.drawElementsIndirectInternal(topology, drawCount, offset, buff);
+	self.drawIndexedIndirectCountInternal(topology, argBuffer, argBufferOffset, countBuffer, countBufferOffset);
+}
+
+void CommandBuffer::drawIndexedIndirect(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* buff)
+{
+	ANKI_VK_SELF(CommandBufferImpl);
+	self.drawIndexedIndirectInternal(topology, drawCount, offset, buff);
 }
 
 void CommandBuffer::dispatchCompute(U32 groupCountX, U32 groupCountY, U32 groupCountZ)
@@ -286,68 +293,67 @@ void CommandBuffer::dispatchCompute(U32 groupCountX, U32 groupCountY, U32 groupC
 	self.dispatchComputeInternal(groupCountX, groupCountY, groupCountZ);
 }
 
-void CommandBuffer::traceRays(const BufferPtr& sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize, U32 hitGroupSbtRecordCount, U32 rayTypeCount,
-							  U32 width, U32 height, U32 depth)
+void CommandBuffer::traceRays(Buffer* sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize, U32 hitGroupSbtRecordCount, U32 rayTypeCount, U32 width,
+							  U32 height, U32 depth)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.traceRaysInternal(sbtBuffer, sbtBufferOffset, sbtRecordSize, hitGroupSbtRecordCount, rayTypeCount, width, height, depth);
 }
 
-void CommandBuffer::generateMipmaps2d(const TextureViewPtr& texView)
+void CommandBuffer::generateMipmaps2d(TextureView* texView)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.generateMipmaps2dInternal(texView);
 }
 
-void CommandBuffer::generateMipmaps3d([[maybe_unused]] const TextureViewPtr& texView)
+void CommandBuffer::generateMipmaps3d([[maybe_unused]] TextureView* texView)
 {
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::blitTextureViews([[maybe_unused]] const TextureViewPtr& srcView, [[maybe_unused]] const TextureViewPtr& destView)
+void CommandBuffer::blitTextureViews([[maybe_unused]] TextureView* srcView, [[maybe_unused]] TextureView* destView)
 {
 	ANKI_ASSERT(!"TODO");
 }
 
-void CommandBuffer::clearTextureView(const TextureViewPtr& texView, const ClearValue& clearValue)
+void CommandBuffer::clearTextureView(TextureView* texView, const ClearValue& clearValue)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.clearTextureViewInternal(texView, clearValue);
 }
 
-void CommandBuffer::copyBufferToTextureView(const BufferPtr& buff, PtrSize offset, PtrSize range, const TextureViewPtr& texView)
+void CommandBuffer::copyBufferToTextureView(Buffer* buff, PtrSize offset, PtrSize range, TextureView* texView)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.copyBufferToTextureViewInternal(buff, offset, range, texView);
 }
 
-void CommandBuffer::fillBuffer(const BufferPtr& buff, PtrSize offset, PtrSize size, U32 value)
+void CommandBuffer::fillBuffer(Buffer* buff, PtrSize offset, PtrSize size, U32 value)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.fillBufferInternal(buff, offset, size, value);
 }
 
-void CommandBuffer::writeOcclusionQueriesResultToBuffer(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset, const BufferPtr& buff)
+void CommandBuffer::writeOcclusionQueriesResultToBuffer(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset, Buffer* buff)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.writeOcclusionQueriesResultToBufferInternal(queries, offset, buff);
 }
 
-void CommandBuffer::copyBufferToBuffer(const BufferPtr& src, const BufferPtr& dst, ConstWeakArray<CopyBufferToBufferInfo> copies)
+void CommandBuffer::copyBufferToBuffer(Buffer* src, Buffer* dst, ConstWeakArray<CopyBufferToBufferInfo> copies)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.copyBufferToBufferInternal(src, dst, copies);
 }
 
-void CommandBuffer::buildAccelerationStructure(const AccelerationStructurePtr& as)
+void CommandBuffer::buildAccelerationStructure(AccelerationStructure* as)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.buildAccelerationStructureInternal(as);
 }
 
-void CommandBuffer::upscale(const GrUpscalerPtr& upscaler, const TextureViewPtr& inColor, const TextureViewPtr& outUpscaledColor,
-							const TextureViewPtr& motionVectors, const TextureViewPtr& depth, const TextureViewPtr& exposure,
-							const Bool resetAccumulation, const Vec2& jitterOffset, const Vec2& motionVectorsScale)
+void CommandBuffer::upscale(GrUpscaler* upscaler, TextureView* inColor, TextureView* outUpscaledColor, TextureView* motionVectors, TextureView* depth,
+							TextureView* exposure, Bool resetAccumulation, const Vec2& jitterOffset, const Vec2& motionVectorsScale)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.upscaleInternal(upscaler, inColor, outUpscaledColor, motionVectors, depth, exposure, resetAccumulation, jitterOffset, motionVectorsScale);
@@ -366,13 +372,13 @@ void CommandBuffer::resetOcclusionQueries(ConstWeakArray<OcclusionQuery*> querie
 	self.resetOcclusionQueriesInternal(queries);
 }
 
-void CommandBuffer::beginOcclusionQuery(const OcclusionQueryPtr& query)
+void CommandBuffer::beginOcclusionQuery(OcclusionQuery* query)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.beginOcclusionQueryInternal(query);
 }
 
-void CommandBuffer::endOcclusionQuery(const OcclusionQueryPtr& query)
+void CommandBuffer::endOcclusionQuery(OcclusionQuery* query)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.endOcclusionQueryInternal(query);
@@ -390,7 +396,7 @@ void CommandBuffer::resetTimestampQueries(ConstWeakArray<TimestampQuery*> querie
 	self.resetTimestampQueriesInternal(queries);
 }
 
-void CommandBuffer::writeTimestamp(const TimestampQueryPtr& query)
+void CommandBuffer::writeTimestamp(TimestampQuery* query)
 {
 	ANKI_VK_SELF(CommandBufferImpl);
 	self.writeTimestampInternal(query);

AnKi/Gr/Vulkan/CommandBufferFactory.h

@@ -52,16 +52,15 @@ public:
 		return m_refcount.load();
 	}
 
-	void setFence(MicroFencePtr& fence)
+	void setFence(MicroFence* fence)
 	{
 		ANKI_ASSERT(!(m_flags & CommandBufferFlag::kSecondLevel));
-		ANKI_ASSERT(!m_fence.isCreated());
-		m_fence = fence;
+		m_fence.reset(fence);
 	}
 
-	MicroFencePtr& getFence()
+	MicroFence* getFence() const
 	{
-		return m_fence;
+		return m_fence.tryGet();
 	}
 
 	/// Interface method.
@@ -81,15 +80,11 @@ public:
 		return m_handle;
 	}
 
-	template<typename T>
-	void pushObjectRef(const GrObjectPtrT<T>& x)
-	{
-		pushToArray(m_objectRefs[T::kClassType], x.get());
-	}
-
 	template<typename T>
 	void pushObjectRef(T* x)
 	{
+		ANKI_ASSERT(T::kClassType != GrObjectType::kTexture && T::kClassType != GrObjectType::kTextureView && T::kClassType != GrObjectType::kBuffer
+					&& "No need to push references of buffers and textures");
 		pushToArray(m_objectRefs[T::kClassType], x);
 	}
 
@@ -143,12 +138,6 @@ private:
 	}
 };
 
-template<>
-inline void MicroCommandBuffer::pushObjectRef<GrObject>(const GrObjectPtr& x)
-{
-	pushToArray(m_objectRefs[x->getType()], x.get());
-}
-
 /// Deleter.
 class MicroCommandBufferPtrDeleter
 {

AnKi/Gr/Vulkan/CommandBufferImpl.cpp

@@ -51,7 +51,7 @@ Error CommandBufferImpl::init(const CommandBufferInitInfo& init)
 		m_activeFb = init.m_framebuffer;
 		m_colorAttachmentUsages = init.m_colorAttachmentUsages;
 		m_depthStencilAttachmentUsage = init.m_depthStencilAttachmentUsage;
-		m_state.beginRenderPass(static_cast<FramebufferImpl*>(m_activeFb.get()));
+		m_state.beginRenderPass(static_cast<FramebufferImpl*>(m_activeFb));
 		m_microCmdb->pushObjectRef(m_activeFb);
 	}
 
@@ -118,7 +118,7 @@ void CommandBufferImpl::beginRecording()
 	}
 }
 
-void CommandBufferImpl::beginRenderPassInternal(const FramebufferPtr& fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
+void CommandBufferImpl::beginRenderPassInternal(Framebuffer* fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 												TextureUsageBit depthStencilAttachmentUsage, U32 minx, U32 miny, U32 width, U32 height)
 {
 	commandCommon();
@@ -248,7 +248,7 @@ void CommandBufferImpl::endRenderPassInternal()
 	vkCmdEndRenderPass2KHR(m_handle, &subpassEndInfo);
 	getGrManagerImpl().endMarker(m_handle);
 
-	m_activeFb.reset(nullptr);
+	m_activeFb = nullptr;
 	m_state.endRenderPass();
 
 	// After pushing second level command buffers the state is undefined. Reset the tracker and rebind the dynamic state
@@ -304,7 +304,7 @@ void CommandBufferImpl::endRecording()
 #endif
 }
 
-void CommandBufferImpl::generateMipmaps2dInternal(const TextureViewPtr& texView)
+void CommandBufferImpl::generateMipmaps2dInternal(TextureView* texView)
 {
 	commandCommon();
 
@@ -391,13 +391,9 @@ void CommandBufferImpl::generateMipmaps2dInternal(const TextureViewPtr& texView)
 		vkCmdBlitImage(m_handle, tex.m_imageHandle, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, tex.m_imageHandle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
 					   &blit, (!!aspect) ? VK_FILTER_NEAREST : VK_FILTER_LINEAR);
 	}
-
-	// Hold the reference
-	m_microCmdb->pushObjectRef(texView);
 }
 
-void CommandBufferImpl::copyBufferToTextureViewInternal(const BufferPtr& buff, PtrSize offset, [[maybe_unused]] PtrSize range,
-														const TextureViewPtr& texView)
+void CommandBufferImpl::copyBufferToTextureViewInternal(Buffer* buff, PtrSize offset, [[maybe_unused]] PtrSize range, TextureView* texView)
 {
 	commandCommon();
 
@@ -442,9 +438,6 @@ void CommandBufferImpl::copyBufferToTextureViewInternal(const BufferPtr& buff, P
 	region.bufferRowLength = 0;
 
 	vkCmdCopyBufferToImage(m_handle, static_cast<const BufferImpl&>(*buff).getHandle(), tex.m_imageHandle, layout, 1, &region);
-
-	m_microCmdb->pushObjectRef(texView);
-	m_microCmdb->pushObjectRef(buff);
 }
 
 void CommandBufferImpl::rebindDynamicState()
@@ -490,7 +483,7 @@ void CommandBufferImpl::rebindDynamicState()
 	}
 }
 
-void CommandBufferImpl::buildAccelerationStructureInternal(const AccelerationStructurePtr& as)
+void CommandBufferImpl::buildAccelerationStructureInternal(AccelerationStructure* as)
 {
 	commandCommon();
 
@@ -514,7 +507,6 @@ void CommandBufferImpl::buildAccelerationStructureInternal(const AccelerationStr
 
 	// Push refs
 	m_microCmdb->pushObjectRef(as);
-	m_microCmdb->pushObjectRef(scratchBuff);
 }
 
 #if ANKI_DLSS
@@ -535,9 +527,9 @@ static NVSDK_NGX_Resource_VK getNGXResourceFromAnkiTexture(const TextureViewImpl
 }
 #endif
 
-void CommandBufferImpl::upscaleInternal(const GrUpscalerPtr& upscaler, const TextureViewPtr& inColor, const TextureViewPtr& outUpscaledColor,
-										const TextureViewPtr& motionVectors, const TextureViewPtr& depth, const TextureViewPtr& exposure,
-										const Bool resetAccumulation, const Vec2& jitterOffset, const Vec2& motionVectorsScale)
+void CommandBufferImpl::upscaleInternal(GrUpscaler* upscaler, TextureView* inColor, TextureView* outUpscaledColor, TextureView* motionVectors,
+										TextureView* depth, TextureView* exposure, const Bool resetAccumulation, const Vec2& jitterOffset,
+										const Vec2& motionVectorsScale)
 {
 #if ANKI_DLSS
 	ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_dlss);
@@ -663,8 +655,6 @@ void CommandBufferImpl::setPipelineBarrierInternal(ConstWeakArray<TextureBarrier
 
 		srcStageMask |= srcStage;
 		dstStageMask |= dstStage;
-
-		m_microCmdb->pushObjectRef(barrier.m_texture);
 	}
 
 	for(const BufferBarrierInfo& barrier : buffers)
@@ -702,8 +692,6 @@ void CommandBufferImpl::setPipelineBarrierInternal(ConstWeakArray<TextureBarrier
 
 		srcStageMask |= srcStage;
 		dstStageMask |= dstStage;
-
-		m_microCmdb->pushObjectRef(barrier.m_buffer);
 	}
 
 	for(const AccelerationStructureBarrierInfo& barrier : accelerationStructures)

AnKi/Gr/Vulkan/CommandBufferImpl.h

@@ -45,7 +45,7 @@ public:
 
 	Error init(const CommandBufferInitInfo& init);
 
-	void setFence(MicroFencePtr& fence)
+	void setFence(MicroFence* fence)
 	{
 		m_microCmdb->setFence(fence);
 	}
@@ -76,47 +76,45 @@ public:
 		return !!(m_flags & CommandBufferFlag::kSecondLevel);
 	}
 
-	void bindVertexBufferInternal(U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate)
+	ANKI_FORCE_INLINE void bindVertexBufferInternal(U32 binding, Buffer* buff, PtrSize offset, PtrSize stride, VertexStepRate stepRate)
 	{
 		commandCommon();
 		m_state.bindVertexBuffer(binding, stride, stepRate);
 		const VkBuffer vkbuff = static_cast<const BufferImpl&>(*buff).getHandle();
 		vkCmdBindVertexBuffers(m_handle, binding, 1, &vkbuff, &offset);
-		m_microCmdb->pushObjectRef(buff);
 	}
 
-	void setVertexAttributeInternal(U32 location, U32 buffBinding, const Format fmt, PtrSize relativeOffset)
+	ANKI_FORCE_INLINE void setVertexAttributeInternal(U32 location, U32 buffBinding, const Format fmt, PtrSize relativeOffset)
 	{
 		commandCommon();
 		m_state.setVertexAttribute(location, buffBinding, fmt, relativeOffset);
 	}
 
-	void bindIndexBufferInternal(const BufferPtr& buff, PtrSize offset, IndexType type)
+	ANKI_FORCE_INLINE void bindIndexBufferInternal(Buffer* buff, PtrSize offset, IndexType type)
 	{
 		commandCommon();
 		vkCmdBindIndexBuffer(m_handle, static_cast<const BufferImpl&>(*buff).getHandle(), offset, convertIndexType(type));
-		m_microCmdb->pushObjectRef(buff);
 	}
 
-	void setPrimitiveRestartInternal(Bool enable)
+	ANKI_FORCE_INLINE void setPrimitiveRestartInternal(Bool enable)
 	{
 		commandCommon();
 		m_state.setPrimitiveRestart(enable);
 	}
 
-	void setFillModeInternal(FillMode mode)
+	ANKI_FORCE_INLINE void setFillModeInternal(FillMode mode)
 	{
 		commandCommon();
 		m_state.setFillMode(mode);
 	}
 
-	void setCullModeInternal(FaceSelectionBit mode)
+	ANKI_FORCE_INLINE void setCullModeInternal(FaceSelectionBit mode)
 	{
 		commandCommon();
 		m_state.setCullMode(mode);
 	}
 
-	void setViewportInternal(U32 minx, U32 miny, U32 width, U32 height)
+	ANKI_FORCE_INLINE void setViewportInternal(U32 minx, U32 miny, U32 width, U32 height)
 	{
 		ANKI_ASSERT(width > 0 && height > 0);
 		commandCommon();
@@ -132,7 +130,7 @@ public:
 		}
 	}
 
-	void setScissorInternal(U32 minx, U32 miny, U32 width, U32 height)
+	ANKI_FORCE_INLINE void setScissorInternal(U32 minx, U32 miny, U32 width, U32 height)
 	{
 		ANKI_ASSERT(width > 0 && height > 0);
 		commandCommon();
@@ -148,21 +146,21 @@ public:
 		}
 	}
 
-	void setPolygonOffsetInternal(F32 factor, F32 units)
+	ANKI_FORCE_INLINE void setPolygonOffsetInternal(F32 factor, F32 units)
 	{
 		commandCommon();
 		m_state.setPolygonOffset(factor, units);
 		vkCmdSetDepthBias(m_handle, factor, 0.0f, units);
 	}
 
-	void setStencilOperationsInternal(FaceSelectionBit face, StencilOperation stencilFail, StencilOperation stencilPassDepthFail,
-									  StencilOperation stencilPassDepthPass)
+	ANKI_FORCE_INLINE void setStencilOperationsInternal(FaceSelectionBit face, StencilOperation stencilFail, StencilOperation stencilPassDepthFail,
+														StencilOperation stencilPassDepthPass)
 	{
 		commandCommon();
 		m_state.setStencilOperations(face, stencilFail, stencilPassDepthFail, stencilPassDepthPass);
 	}
 
-	void setStencilCompareOperationInternal(FaceSelectionBit face, CompareOperation comp)
+	ANKI_FORCE_INLINE void setStencilCompareOperationInternal(FaceSelectionBit face, CompareOperation comp)
 	{
 		commandCommon();
 		m_state.setStencilCompareOperation(face, comp);
@@ -174,43 +172,43 @@ public:
 
 	void setStencilReferenceInternal(FaceSelectionBit face, U32 ref);
 
-	void setDepthWriteInternal(Bool enable)
+	ANKI_FORCE_INLINE void setDepthWriteInternal(Bool enable)
 	{
 		commandCommon();
 		m_state.setDepthWrite(enable);
 	}
 
-	void setDepthCompareOperationInternal(CompareOperation op)
+	ANKI_FORCE_INLINE void setDepthCompareOperationInternal(CompareOperation op)
 	{
 		commandCommon();
 		m_state.setDepthCompareOperation(op);
 	}
 
-	void setAlphaToCoverageInternal(Bool enable)
+	ANKI_FORCE_INLINE void setAlphaToCoverageInternal(Bool enable)
 	{
 		commandCommon();
 		m_state.setAlphaToCoverage(enable);
 	}
 
-	void setColorChannelWriteMaskInternal(U32 attachment, ColorBit mask)
+	ANKI_FORCE_INLINE void setColorChannelWriteMaskInternal(U32 attachment, ColorBit mask)
 	{
 		commandCommon();
 		m_state.setColorChannelWriteMask(attachment, mask);
 	}
 
-	void setBlendFactorsInternal(U32 attachment, BlendFactor srcRgb, BlendFactor dstRgb, BlendFactor srcA, BlendFactor dstA)
+	ANKI_FORCE_INLINE void setBlendFactorsInternal(U32 attachment, BlendFactor srcRgb, BlendFactor dstRgb, BlendFactor srcA, BlendFactor dstA)
 	{
 		commandCommon();
 		m_state.setBlendFactors(attachment, srcRgb, dstRgb, srcA, dstA);
 	}
 
-	void setBlendOperationInternal(U32 attachment, BlendOperation funcRgb, BlendOperation funcA)
+	ANKI_FORCE_INLINE void setBlendOperationInternal(U32 attachment, BlendOperation funcRgb, BlendOperation funcA)
 	{
 		commandCommon();
 		m_state.setBlendOperation(attachment, funcRgb, funcA);
 	}
 
-	void bindTextureAndSamplerInternal(U32 set, U32 binding, const TextureViewPtr& texView, const SamplerPtr& sampler, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindTextureAndSamplerInternal(U32 set, U32 binding, TextureView* texView, Sampler* sampler, U32 arrayIdx)
 	{
 		commandCommon();
 		const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
@@ -218,13 +216,12 @@ public:
 		ANKI_ASSERT(tex.isSubresourceGoodForSampling(view.getSubresource()));
 		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::kAllSampled & tex.getTextureUsage(), 0);
 
-		m_dsetState[set].bindTextureAndSampler(binding, arrayIdx, &view, sampler.get(), lay);
+		m_dsetState[set].bindTextureAndSampler(binding, arrayIdx, &view, sampler, lay);
 
-		m_microCmdb->pushObjectRef(texView);
 		m_microCmdb->pushObjectRef(sampler);
 	}
 
-	void bindTextureInternal(U32 set, U32 binding, const TextureViewPtr& texView, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindTextureInternal(U32 set, U32 binding, TextureView* texView, U32 arrayIdx)
 	{
 		commandCommon();
 		const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
@@ -232,78 +229,133 @@ public:
 		ANKI_ASSERT(tex.isSubresourceGoodForSampling(view.getSubresource()));
 		const VkImageLayout lay = tex.computeLayout(TextureUsageBit::kAllSampled & tex.getTextureUsage(), 0);
 
-		m_dsetState[set].bindTexture(binding, arrayIdx, &view, lay);
-
-		m_microCmdb->pushObjectRef(texView);
+		m_dsetState[set].bindTexture(binding, arrayIdx, texView, lay);
 	}
 
-	void bindSamplerInternal(U32 set, U32 binding, const SamplerPtr& sampler, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindSamplerInternal(U32 set, U32 binding, Sampler* sampler, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindSampler(binding, arrayIdx, sampler.get());
+		m_dsetState[set].bindSampler(binding, arrayIdx, sampler);
 		m_microCmdb->pushObjectRef(sampler);
 	}
 
-	void bindImageInternal(U32 set, U32 binding, const TextureViewPtr& img, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindImageInternal(U32 set, U32 binding, TextureView* img, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindImage(binding, arrayIdx, img.get());
+		m_dsetState[set].bindImage(binding, arrayIdx, img);
 
 		const Bool isPresentable = !!(static_cast<const TextureViewImpl&>(*img).getTextureImpl().getTextureUsage() & TextureUsageBit::kPresent);
 		if(isPresentable)
 		{
 			m_renderedToDefaultFb = true;
 		}
-
-		m_microCmdb->pushObjectRef(img);
 	}
 
-	void bindAccelerationStructureInternal(U32 set, U32 binding, const AccelerationStructurePtr& as, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindAccelerationStructureInternal(U32 set, U32 binding, AccelerationStructure* as, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindAccelerationStructure(binding, arrayIdx, as.get());
+		m_dsetState[set].bindAccelerationStructure(binding, arrayIdx, as);
 		m_microCmdb->pushObjectRef(as);
 	}
 
-	void bindAllBindlessInternal(U32 set)
+	ANKI_FORCE_INLINE void bindAllBindlessInternal(U32 set)
 	{
 		commandCommon();
 		m_dsetState[set].bindBindlessDescriptorSet();
 	}
 
-	void beginRenderPassInternal(const FramebufferPtr& fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
+	void beginRenderPassInternal(Framebuffer* fb, const Array<TextureUsageBit, kMaxColorRenderTargets>& colorAttachmentUsages,
 								 TextureUsageBit depthStencilAttachmentUsage, U32 minx, U32 miny, U32 width, U32 height);
 
 	void endRenderPassInternal();
 
-	void setVrsRateInternal(VrsRate rate);
+	ANKI_FORCE_INLINE void setVrsRateInternal(VrsRate rate)
+	{
+		ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_vrs);
+		ANKI_ASSERT(rate < VrsRate::kCount);
+		commandCommon();
+
+		if(m_vrsRate != rate)
+		{
+			m_vrsRate = rate;
+			m_vrsRateDirty = true;
+		}
+	}
+
+	ANKI_FORCE_INLINE void drawInternal(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
+	{
+		m_state.setPrimitiveTopology(topology);
+		drawcallCommon();
+		vkCmdDraw(m_handle, count, instanceCount, first, baseInstance);
+	}
 
-	void drawArraysInternal(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 first, U32 baseInstance);
+	ANKI_FORCE_INLINE void drawIndexedInternal(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 firstIndex, U32 baseVertex,
+											   U32 baseInstance)
+	{
+		m_state.setPrimitiveTopology(topology);
+		drawcallCommon();
+		vkCmdDrawIndexed(m_handle, count, instanceCount, firstIndex, baseVertex, baseInstance);
+	}
 
-	void drawElementsInternal(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 firstIndex, U32 baseVertex, U32 baseInstance);
+	ANKI_FORCE_INLINE void drawIndirectInternal(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* buff)
+	{
+		m_state.setPrimitiveTopology(topology);
+		drawcallCommon();
+		const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
+		ANKI_ASSERT(impl.usageValid(BufferUsageBit::kIndirectDraw));
+		ANKI_ASSERT((offset % 4) == 0);
+		ANKI_ASSERT((offset + sizeof(DrawIndirectArgs) * drawCount) <= impl.getSize());
 
-	void drawArraysIndirectInternal(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& buff);
+		vkCmdDrawIndirect(m_handle, impl.getHandle(), offset, drawCount, sizeof(DrawIndirectArgs));
+	}
+
+	ANKI_FORCE_INLINE void drawIndexedIndirectInternal(PrimitiveTopology topology, U32 drawCount, PtrSize offset, Buffer* buff)
+	{
+		m_state.setPrimitiveTopology(topology);
+		drawcallCommon();
+		const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
+		ANKI_ASSERT(impl.usageValid(BufferUsageBit::kIndirectDraw));
+		ANKI_ASSERT((offset % 4) == 0);
+		ANKI_ASSERT((offset + sizeof(DrawIndexedIndirectArgs) * drawCount) <= impl.getSize());
 
-	void drawElementsIndirectInternal(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& buff);
+		vkCmdDrawIndexedIndirect(m_handle, impl.getHandle(), offset, drawCount, sizeof(DrawIndexedIndirectArgs));
+	}
+
+	ANKI_FORCE_INLINE void drawIndexedIndirectCountInternal(PrimitiveTopology topology, Buffer* argBuffer, PtrSize argBufferOffset,
+															Buffer* countBuffer, PtrSize countBufferOffset)
+	{
+		m_state.setPrimitiveTopology(topology);
+		drawcallCommon();
+		const BufferImpl& argBufferImpl = static_cast<const BufferImpl&>(*argBuffer);
+		ANKI_ASSERT(argBufferImpl.usageValid(BufferUsageBit::kIndirectDraw));
+		ANKI_ASSERT((argBufferOffset % 4) == 0);
+
+		const BufferImpl& countBufferImpl = static_cast<const BufferImpl&>(*countBuffer);
+		ANKI_ASSERT(countBufferImpl.usageValid(BufferUsageBit::kIndirectDraw));
+		ANKI_ASSERT((countBufferOffset % 4) == 0);
+
+		vkCmdDrawIndexedIndirectCountKHR(m_handle, argBufferImpl.getHandle(), argBufferOffset, countBufferImpl.getHandle(), countBufferOffset,
+										 kMaxU32, sizeof(DrawIndexedIndirectArgs));
+	}
 
 	void dispatchComputeInternal(U32 groupCountX, U32 groupCountY, U32 groupCountZ);
 
-	void traceRaysInternal(const BufferPtr& sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize, U32 hitGroupSbtRecordCount, U32 rayTypeCount,
-						   U32 width, U32 height, U32 depth);
+	void traceRaysInternal(Buffer* sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize, U32 hitGroupSbtRecordCount, U32 rayTypeCount, U32 width,
+						   U32 height, U32 depth);
 
 	void resetOcclusionQueriesInternal(ConstWeakArray<OcclusionQuery*> queries);
 
-	void beginOcclusionQueryInternal(const OcclusionQueryPtr& query);
+	void beginOcclusionQueryInternal(OcclusionQuery* query);
 
-	void endOcclusionQueryInternal(const OcclusionQueryPtr& query);
+	void endOcclusionQueryInternal(OcclusionQuery* query);
 
 	void resetTimestampQueriesInternal(ConstWeakArray<TimestampQuery*> queries);
 
-	void writeTimestampInternal(const TimestampQueryPtr& query);
+	void writeTimestampInternal(TimestampQuery* query);
 
-	void generateMipmaps2dInternal(const TextureViewPtr& texView);
+	void generateMipmaps2dInternal(TextureView* texView);
 
-	void clearTextureViewInternal(const TextureViewPtr& texView, const ClearValue& clearValue);
+	void clearTextureViewInternal(TextureView* texView, const ClearValue& clearValue);
 
 	void pushSecondLevelCommandBuffersInternal(ConstWeakArray<CommandBuffer*> cmdbs);
 
@@ -318,48 +370,61 @@ public:
 	void setPipelineBarrierInternal(ConstWeakArray<TextureBarrierInfo> textures, ConstWeakArray<BufferBarrierInfo> buffers,
 									ConstWeakArray<AccelerationStructureBarrierInfo> accelerationStructures);
 
-	void fillBufferInternal(const BufferPtr& buff, PtrSize offset, PtrSize size, U32 value);
+	void fillBufferInternal(Buffer* buff, PtrSize offset, PtrSize size, U32 value);
 
-	void writeOcclusionQueriesResultToBufferInternal(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset, const BufferPtr& buff);
+	void writeOcclusionQueriesResultToBufferInternal(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset, Buffer* buff);
 
-	void bindShaderProgramInternal(const ShaderProgramPtr& prog);
+	void bindShaderProgramInternal(ShaderProgram* prog);
 
-	void bindUniformBufferInternal(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindUniformBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindUniformBuffer(binding, arrayIdx, buff.get(), offset, range);
-		m_microCmdb->pushObjectRef(buff);
+		m_dsetState[set].bindUniformBuffer(binding, arrayIdx, buff, offset, range);
 	}
 
-	void bindStorageBufferInternal(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindStorageBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindStorageBuffer(binding, arrayIdx, buff.get(), offset, range);
-		m_microCmdb->pushObjectRef(buff);
+		m_dsetState[set].bindStorageBuffer(binding, arrayIdx, buff, offset, range);
 	}
 
-	void bindReadOnlyTextureBufferInternal(U32 set, U32 binding, const BufferPtr& buff, PtrSize offset, PtrSize range, Format fmt, U32 arrayIdx)
+	ANKI_FORCE_INLINE void bindReadOnlyTextureBufferInternal(U32 set, U32 binding, Buffer* buff, PtrSize offset, PtrSize range, Format fmt,
+															 U32 arrayIdx)
 	{
 		commandCommon();
-		m_dsetState[set].bindReadOnlyTextureBuffer(binding, arrayIdx, buff.get(), offset, range, fmt);
-		m_microCmdb->pushObjectRef(buff);
+		m_dsetState[set].bindReadOnlyTextureBuffer(binding, arrayIdx, buff, offset, range, fmt);
 	}
 
-	void copyBufferToTextureViewInternal(const BufferPtr& buff, PtrSize offset, PtrSize range, const TextureViewPtr& texView);
+	void copyBufferToTextureViewInternal(Buffer* buff, PtrSize offset, PtrSize range, TextureView* texView);
 
-	void copyBufferToBufferInternal(const BufferPtr& src, const BufferPtr& dst, ConstWeakArray<CopyBufferToBufferInfo> copies);
+	void copyBufferToBufferInternal(Buffer* src, Buffer* dst, ConstWeakArray<CopyBufferToBufferInfo> copies);
 
-	void buildAccelerationStructureInternal(const AccelerationStructurePtr& as);
+	void buildAccelerationStructureInternal(AccelerationStructure* as);
 
-	void upscaleInternal(const GrUpscalerPtr& upscaler, const TextureViewPtr& inColor, const TextureViewPtr& outUpscaledColor,
-						 const TextureViewPtr& motionVectors, const TextureViewPtr& depth, const TextureViewPtr& exposure,
-						 const Bool resetAccumulation, const Vec2& jitterOffset, const Vec2& motionVectorsScale);
+	void upscaleInternal(GrUpscaler* upscaler, TextureView* inColor, TextureView* outUpscaledColor, TextureView* motionVectors, TextureView* depth,
+						 TextureView* exposure, const Bool resetAccumulation, const Vec2& jitterOffset, const Vec2& motionVectorsScale);
 
 	void setPushConstantsInternal(const void* data, U32 dataSize);
 
-	void setRasterizationOrderInternal(RasterizationOrder order);
+	ANKI_FORCE_INLINE void setRasterizationOrderInternal(RasterizationOrder order)
+	{
+		commandCommon();
 
-	void setLineWidthInternal(F32 width);
+		if(!!(getGrManagerImpl().getExtensions() & VulkanExtensions::kAMD_rasterization_order))
+		{
+			m_state.setRasterizationOrder(order);
+		}
+	}
+
+	ANKI_FORCE_INLINE void setLineWidthInternal(F32 width)
+	{
+		commandCommon();
+		vkCmdSetLineWidth(m_handle, width);
+
+#if ANKI_ENABLE_ASSERTIONS
+		m_lineWidthSet = true;
+#endif
+	}
 
 private:
 	StackMemoryPool* m_pool = nullptr;
@@ -377,7 +442,7 @@ private:
 	U32 m_setPushConstantsSize = 0;
 #endif
 
-	FramebufferPtr m_activeFb;
+	Framebuffer* m_activeFb = nullptr;
 	Array<U32, 4> m_renderArea = {0, 0, kMaxU32, kMaxU32};
 	Array<U32, 2> m_fbSize = {0, 0};
 	U32 m_rpCommandCount = 0; ///< Number of drawcalls or pushed cmdbs in rp.
@@ -438,7 +503,7 @@ private:
 
 	Bool insideRenderPass() const
 	{
-		return m_activeFb.isCreated();
+		return m_activeFb != nullptr;
 	}
 
 	void beginRenderPassInternal();

AnKi/Gr/Vulkan/CommandBufferImpl.inl.h

@@ -13,7 +13,7 @@
 
 namespace anki {
 
-inline void CommandBufferImpl::setStencilCompareMaskInternal(FaceSelectionBit face, U32 mask)
+ANKI_FORCE_INLINE void CommandBufferImpl::setStencilCompareMaskInternal(FaceSelectionBit face, U32 mask)
 {
 	commandCommon();
 
@@ -37,7 +37,7 @@ inline void CommandBufferImpl::setStencilCompareMaskInternal(FaceSelectionBit fa
 	}
 }
 
-inline void CommandBufferImpl::setStencilWriteMaskInternal(FaceSelectionBit face, U32 mask)
+ANKI_FORCE_INLINE void CommandBufferImpl::setStencilWriteMaskInternal(FaceSelectionBit face, U32 mask)
 {
 	commandCommon();
 
@@ -61,7 +61,7 @@ inline void CommandBufferImpl::setStencilWriteMaskInternal(FaceSelectionBit face
 	}
 }
 
-inline void CommandBufferImpl::setStencilReferenceInternal(FaceSelectionBit face, U32 ref)
+ANKI_FORCE_INLINE void CommandBufferImpl::setStencilReferenceInternal(FaceSelectionBit face, U32 ref)
 {
 	commandCommon();
 
@@ -85,9 +85,9 @@ inline void CommandBufferImpl::setStencilReferenceInternal(FaceSelectionBit face
 	}
 }
 
-inline void CommandBufferImpl::setImageBarrier(VkPipelineStageFlags srcStage, VkAccessFlags srcAccess, VkImageLayout prevLayout,
-											   VkPipelineStageFlags dstStage, VkAccessFlags dstAccess, VkImageLayout newLayout, VkImage img,
-											   const VkImageSubresourceRange& range)
+ANKI_FORCE_INLINE void CommandBufferImpl::setImageBarrier(VkPipelineStageFlags srcStage, VkAccessFlags srcAccess, VkImageLayout prevLayout,
+														  VkPipelineStageFlags dstStage, VkAccessFlags dstAccess, VkImageLayout newLayout,
+														  VkImage img, const VkImageSubresourceRange& range)
 {
 	ANKI_ASSERT(img);
 	commandCommon();
@@ -107,46 +107,7 @@ inline void CommandBufferImpl::setImageBarrier(VkPipelineStageFlags srcStage, Vk
 	ANKI_TRACE_INC_COUNTER(VkBarrier, 1);
 }
 
-inline void CommandBufferImpl::drawArraysInternal(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
-{
-	m_state.setPrimitiveTopology(topology);
-	drawcallCommon();
-	vkCmdDraw(m_handle, count, instanceCount, first, baseInstance);
-}
-
-inline void CommandBufferImpl::drawElementsInternal(PrimitiveTopology topology, U32 count, U32 instanceCount, U32 firstIndex, U32 baseVertex,
-													U32 baseInstance)
-{
-	m_state.setPrimitiveTopology(topology);
-	drawcallCommon();
-	vkCmdDrawIndexed(m_handle, count, instanceCount, firstIndex, baseVertex, baseInstance);
-}
-
-inline void CommandBufferImpl::drawArraysIndirectInternal(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& buff)
-{
-	m_state.setPrimitiveTopology(topology);
-	drawcallCommon();
-	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kIndirectDraw));
-	ANKI_ASSERT((offset % 4) == 0);
-	ANKI_ASSERT((offset + sizeof(DrawIndirectArgs) * drawCount) <= impl.getSize());
-
-	vkCmdDrawIndirect(m_handle, impl.getHandle(), offset, drawCount, sizeof(DrawIndirectArgs));
-}
-
-inline void CommandBufferImpl::drawElementsIndirectInternal(PrimitiveTopology topology, U32 drawCount, PtrSize offset, const BufferPtr& buff)
-{
-	m_state.setPrimitiveTopology(topology);
-	drawcallCommon();
-	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kIndirectDraw));
-	ANKI_ASSERT((offset % 4) == 0);
-	ANKI_ASSERT((offset + sizeof(DrawIndexedIndirectArgs) * drawCount) <= impl.getSize());
-
-	vkCmdDrawIndexedIndirect(m_handle, impl.getHandle(), offset, drawCount, sizeof(DrawIndexedIndirectArgs));
-}
-
-inline void CommandBufferImpl::dispatchComputeInternal(U32 groupCountX, U32 groupCountY, U32 groupCountZ)
+ANKI_FORCE_INLINE void CommandBufferImpl::dispatchComputeInternal(U32 groupCountX, U32 groupCountY, U32 groupCountZ)
 {
 	ANKI_ASSERT(m_computeProg);
 	ANKI_ASSERT(m_computeProg->getReflectionInfo().m_pushConstantsSize == m_setPushConstantsSize && "Forgot to set pushConstants");
@@ -192,8 +153,8 @@ inline void CommandBufferImpl::dispatchComputeInternal(U32 groupCountX, U32 grou
 	getGrManagerImpl().endMarker(m_handle);
 }
 
-inline void CommandBufferImpl::traceRaysInternal(const BufferPtr& sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize32, U32 hitGroupSbtRecordCount,
-												 U32 rayTypeCount, U32 width, U32 height, U32 depth)
+ANKI_FORCE_INLINE void CommandBufferImpl::traceRaysInternal(Buffer* sbtBuffer, PtrSize sbtBufferOffset, U32 sbtRecordSize32,
+															U32 hitGroupSbtRecordCount, U32 rayTypeCount, U32 width, U32 height, U32 depth)
 {
 	const PtrSize sbtRecordSize = sbtRecordSize32;
 	ANKI_ASSERT(hitGroupSbtRecordCount > 0);
@@ -272,105 +233,7 @@ inline void CommandBufferImpl::traceRaysInternal(const BufferPtr& sbtBuffer, Ptr
 	getGrManagerImpl().endMarker(m_handle);
 }
 
-inline void CommandBufferImpl::resetOcclusionQueriesInternal(ConstWeakArray<OcclusionQuery*> queries)
-{
-	ANKI_ASSERT(queries.getSize() > 0);
-
-	commandCommon();
-
-	for(U32 i = 0; i < queries.getSize(); ++i)
-	{
-		OcclusionQuery* query = queries[i];
-		ANKI_ASSERT(query);
-		const VkQueryPool poolHandle = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryPool();
-		const U32 idx = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryIndex();
-
-		vkCmdResetQueryPool(m_handle, poolHandle, idx, 1);
-		m_microCmdb->pushObjectRef(query);
-	}
-}
-
-inline void CommandBufferImpl::beginOcclusionQueryInternal(const OcclusionQueryPtr& query)
-{
-	commandCommon();
-
-	const VkQueryPool handle = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryPool();
-	const U32 idx = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryIndex();
-	ANKI_ASSERT(handle);
-
-	vkCmdBeginQuery(m_handle, handle, idx, 0);
-
-	m_microCmdb->pushObjectRef(query);
-}
-
-inline void CommandBufferImpl::endOcclusionQueryInternal(const OcclusionQueryPtr& query)
-{
-	commandCommon();
-
-	const VkQueryPool handle = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryPool();
-	const U32 idx = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryIndex();
-	ANKI_ASSERT(handle);
-
-	vkCmdEndQuery(m_handle, handle, idx);
-
-	m_microCmdb->pushObjectRef(query);
-}
-
-inline void CommandBufferImpl::resetTimestampQueriesInternal(ConstWeakArray<TimestampQuery*> queries)
-{
-	ANKI_ASSERT(queries.getSize() > 0);
-
-	commandCommon();
-
-	for(U32 i = 0; i < queries.getSize(); ++i)
-	{
-		TimestampQuery* query = queries[i];
-		ANKI_ASSERT(query);
-		const VkQueryPool poolHandle = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryPool();
-		const U32 idx = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryIndex();
-
-		vkCmdResetQueryPool(m_handle, poolHandle, idx, 1);
-		m_microCmdb->pushObjectRef(query);
-	}
-}
-
-inline void CommandBufferImpl::writeTimestampInternal(const TimestampQueryPtr& query)
-{
-	commandCommon();
-
-	const VkQueryPool handle = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryPool();
-	const U32 idx = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryIndex();
-
-	vkCmdWriteTimestamp(m_handle, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, handle, idx);
-
-	m_microCmdb->pushObjectRef(query);
-}
-
-inline void CommandBufferImpl::clearTextureViewInternal(const TextureViewPtr& texView, const ClearValue& clearValue)
-{
-	commandCommon();
-
-	const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
-	const TextureImpl& tex = view.getTextureImpl();
-
-	VkClearColorValue vclear;
-	static_assert(sizeof(vclear) == sizeof(clearValue), "See file");
-	memcpy(&vclear, &clearValue, sizeof(clearValue));
-
-	if(!view.getSubresource().m_depthStencilAspect)
-	{
-		VkImageSubresourceRange vkRange = view.getVkImageSubresourceRange();
-		vkCmdClearColorImage(m_handle, tex.m_imageHandle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &vclear, 1, &vkRange);
-	}
-	else
-	{
-		ANKI_ASSERT(!"TODO");
-	}
-
-	m_microCmdb->pushObjectRef(texView);
-}
-
-inline void CommandBufferImpl::pushSecondLevelCommandBuffersInternal(ConstWeakArray<CommandBuffer*> cmdbs)
+ANKI_FORCE_INLINE void CommandBufferImpl::pushSecondLevelCommandBuffersInternal(ConstWeakArray<CommandBuffer*> cmdbs)
 {
 	ANKI_ASSERT(cmdbs.getSize() > 0);
 	commandCommon();
@@ -398,7 +261,7 @@ inline void CommandBufferImpl::pushSecondLevelCommandBuffersInternal(ConstWeakAr
 	++m_rpCommandCount;
 }
 
-inline void CommandBufferImpl::drawcallCommon()
+ANKI_FORCE_INLINE void CommandBufferImpl::drawcallCommon()
 {
 	// Preconditions
 	commandCommon();
@@ -521,28 +384,8 @@ inline void CommandBufferImpl::drawcallCommon()
 	ANKI_TRACE_INC_COUNTER(VkDrawcall, 1);
 }
 
-inline void CommandBufferImpl::fillBufferInternal(const BufferPtr& buff, PtrSize offset, PtrSize size, U32 value)
-{
-	commandCommon();
-	ANKI_ASSERT(!insideRenderPass());
-	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
-	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kTransferDestination));
-
-	ANKI_ASSERT(offset < impl.getSize());
-	ANKI_ASSERT((offset % 4) == 0 && "Should be multiple of 4");
-
-	size = (size == kMaxPtrSize) ? (impl.getActualSize() - offset) : size;
-	alignRoundUp(4, size); // Needs to be multiple of 4
-	ANKI_ASSERT(offset + size <= impl.getActualSize());
-	ANKI_ASSERT((size % 4) == 0 && "Should be multiple of 4");
-
-	vkCmdFillBuffer(m_handle, impl.getHandle(), offset, size, value);
-
-	m_microCmdb->pushObjectRef(buff);
-}
-
-inline void CommandBufferImpl::writeOcclusionQueriesResultToBufferInternal(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset,
-																		   const BufferPtr& buff)
+ANKI_FORCE_INLINE void CommandBufferImpl::writeOcclusionQueriesResultToBufferInternal(ConstWeakArray<OcclusionQuery*> queries, PtrSize offset,
+																					  Buffer* buff)
 {
 	ANKI_ASSERT(queries.getSize() > 0);
 	commandCommon();
@@ -565,11 +408,9 @@ inline void CommandBufferImpl::writeOcclusionQueriesResultToBufferInternal(Const
 		offset += sizeof(U32);
 		m_microCmdb->pushObjectRef(q);
 	}
-
-	m_microCmdb->pushObjectRef(buff);
 }
 
-inline void CommandBufferImpl::bindShaderProgramInternal(const ShaderProgramPtr& prog)
+ANKI_FORCE_INLINE void CommandBufferImpl::bindShaderProgramInternal(ShaderProgram* prog)
 {
 	commandCommon();
 
@@ -623,7 +464,7 @@ inline void CommandBufferImpl::bindShaderProgramInternal(const ShaderProgramPtr&
 #endif
 }
 
-inline void CommandBufferImpl::copyBufferToBufferInternal(const BufferPtr& src, const BufferPtr& dst, ConstWeakArray<CopyBufferToBufferInfo> copies)
+ANKI_FORCE_INLINE void CommandBufferImpl::copyBufferToBufferInternal(Buffer* src, Buffer* dst, ConstWeakArray<CopyBufferToBufferInfo> copies)
 {
 	ANKI_ASSERT(static_cast<const BufferImpl&>(*src).usageValid(BufferUsageBit::kTransferSource));
 	ANKI_ASSERT(static_cast<const BufferImpl&>(*dst).usageValid(BufferUsageBit::kTransferDestination));
@@ -636,17 +477,14 @@ inline void CommandBufferImpl::copyBufferToBufferInternal(const BufferPtr& src,
 
 	vkCmdCopyBuffer(m_handle, static_cast<const BufferImpl&>(*src).getHandle(), static_cast<const BufferImpl&>(*dst).getHandle(), copies.getSize(),
 					&vkCopies[0]);
-
-	m_microCmdb->pushObjectRef(src);
-	m_microCmdb->pushObjectRef(dst);
 }
 
-inline Bool CommandBufferImpl::flipViewport() const
+ANKI_FORCE_INLINE Bool CommandBufferImpl::flipViewport() const
 {
 	return static_cast<const FramebufferImpl&>(*m_activeFb).hasPresentableTexture();
 }
 
-inline void CommandBufferImpl::setPushConstantsInternal(const void* data, U32 dataSize)
+ANKI_FORCE_INLINE void CommandBufferImpl::setPushConstantsInternal(const void* data, U32 dataSize)
 {
 	ANKI_ASSERT(data && dataSize && dataSize % 16 == 0);
 	const ShaderProgramImpl& prog = getBoundProgram();
@@ -662,38 +500,118 @@ inline void CommandBufferImpl::setPushConstantsInternal(const void* data, U32 da
 #endif
 }
 
-inline void CommandBufferImpl::setRasterizationOrderInternal(RasterizationOrder order)
+ANKI_FORCE_INLINE void CommandBufferImpl::resetOcclusionQueriesInternal(ConstWeakArray<OcclusionQuery*> queries)
 {
+	ANKI_ASSERT(queries.getSize() > 0);
+
 	commandCommon();
 
-	if(!!(getGrManagerImpl().getExtensions() & VulkanExtensions::kAMD_rasterization_order))
+	for(U32 i = 0; i < queries.getSize(); ++i)
 	{
-		m_state.setRasterizationOrder(order);
+		OcclusionQuery* query = queries[i];
+		ANKI_ASSERT(query);
+		const VkQueryPool poolHandle = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryPool();
+		const U32 idx = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryIndex();
+
+		vkCmdResetQueryPool(m_handle, poolHandle, idx, 1);
+		m_microCmdb->pushObjectRef(query);
 	}
 }
 
-inline void CommandBufferImpl::setLineWidthInternal(F32 width)
+ANKI_FORCE_INLINE void CommandBufferImpl::beginOcclusionQueryInternal(OcclusionQuery* query)
 {
 	commandCommon();
-	vkCmdSetLineWidth(m_handle, width);
 
-#if ANKI_ENABLE_ASSERTIONS
-	m_lineWidthSet = true;
-#endif
+	const VkQueryPool handle = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryPool();
+	const U32 idx = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryIndex();
+	ANKI_ASSERT(handle);
+
+	vkCmdBeginQuery(m_handle, handle, idx, 0);
+
+	m_microCmdb->pushObjectRef(query);
+}
+
+ANKI_FORCE_INLINE void CommandBufferImpl::endOcclusionQueryInternal(OcclusionQuery* query)
+{
+	commandCommon();
+
+	const VkQueryPool handle = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryPool();
+	const U32 idx = static_cast<const OcclusionQueryImpl&>(*query).m_handle.getQueryIndex();
+	ANKI_ASSERT(handle);
+
+	vkCmdEndQuery(m_handle, handle, idx);
+
+	m_microCmdb->pushObjectRef(query);
+}
+
+ANKI_FORCE_INLINE void CommandBufferImpl::resetTimestampQueriesInternal(ConstWeakArray<TimestampQuery*> queries)
+{
+	ANKI_ASSERT(queries.getSize() > 0);
+
+	commandCommon();
+
+	for(U32 i = 0; i < queries.getSize(); ++i)
+	{
+		TimestampQuery* query = queries[i];
+		ANKI_ASSERT(query);
+		const VkQueryPool poolHandle = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryPool();
+		const U32 idx = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryIndex();
+
+		vkCmdResetQueryPool(m_handle, poolHandle, idx, 1);
+		m_microCmdb->pushObjectRef(query);
+	}
 }
 
-inline void CommandBufferImpl::setVrsRateInternal(VrsRate rate)
+ANKI_FORCE_INLINE void CommandBufferImpl::writeTimestampInternal(TimestampQuery* query)
 {
-	ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_vrs);
-	ANKI_ASSERT(rate < VrsRate::kCount);
+	commandCommon();
 
+	const VkQueryPool handle = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryPool();
+	const U32 idx = static_cast<const TimestampQueryImpl&>(*query).m_handle.getQueryIndex();
+
+	vkCmdWriteTimestamp(m_handle, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, handle, idx);
+
+	m_microCmdb->pushObjectRef(query);
+}
+
+ANKI_FORCE_INLINE void CommandBufferImpl::clearTextureViewInternal(TextureView* texView, const ClearValue& clearValue)
+{
 	commandCommon();
 
-	if(m_vrsRate != rate)
+	const TextureViewImpl& view = static_cast<const TextureViewImpl&>(*texView);
+	const TextureImpl& tex = view.getTextureImpl();
+
+	VkClearColorValue vclear;
+	static_assert(sizeof(vclear) == sizeof(clearValue), "See file");
+	memcpy(&vclear, &clearValue, sizeof(clearValue));
+
+	if(!view.getSubresource().m_depthStencilAspect)
+	{
+		VkImageSubresourceRange vkRange = view.getVkImageSubresourceRange();
+		vkCmdClearColorImage(m_handle, tex.m_imageHandle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &vclear, 1, &vkRange);
+	}
+	else
 	{
-		m_vrsRate = rate;
-		m_vrsRateDirty = true;
+		ANKI_ASSERT(!"TODO");
 	}
 }
 
+ANKI_FORCE_INLINE void CommandBufferImpl::fillBufferInternal(Buffer* buff, PtrSize offset, PtrSize size, U32 value)
+{
+	commandCommon();
+	ANKI_ASSERT(!insideRenderPass());
+	const BufferImpl& impl = static_cast<const BufferImpl&>(*buff);
+	ANKI_ASSERT(impl.usageValid(BufferUsageBit::kTransferDestination));
+
+	ANKI_ASSERT(offset < impl.getSize());
+	ANKI_ASSERT((offset % 4) == 0 && "Should be multiple of 4");
+
+	size = (size == kMaxPtrSize) ? (impl.getActualSize() - offset) : size;
+	alignRoundUp(4, size); // Needs to be multiple of 4
+	ANKI_ASSERT(offset + size <= impl.getActualSize());
+	ANKI_ASSERT((size % 4) == 0 && "Should be multiple of 4");
+
+	vkCmdFillBuffer(m_handle, impl.getHandle(), offset, size, value);
+}
+
 } // end namespace anki

AnKi/Gr/Vulkan/Common.h

@@ -95,6 +95,7 @@ enum class VulkanExtensions : U32
 	kNVX_image_view_handle = 1 << 27,
 	kKHR_push_descriptor = 1 << 28,
 	kKHR_maintenance_4 = 1 << 29,
+	kKHR_draw_indirect_count = 1 << 30
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(VulkanExtensions)
 

AnKi/Gr/Vulkan/DeferredBarrierFactory.h

@@ -62,14 +62,14 @@ public:
 		return m_refcount.load();
 	}
 
-	void setFence(MicroFencePtr& f)
+	void setFence(MicroFence* f)
 	{
-		m_fence = f;
+		m_fence.reset(f);
 	}
 
-	MicroFencePtr& getFence()
+	MicroFence* getFence() const
 	{
-		return m_fence;
+		return m_fence.tryGet();
 	}
 
 	/// Interface method.

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -537,6 +537,7 @@ Error GrManagerImpl::initInstance()
 		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minTexelBufferOffsetAlignment));
 	m_capabilities.m_textureBufferMaxRange = kMaxU32;
 	m_capabilities.m_computeSharedMemorySize = m_devProps.properties.limits.maxComputeSharedMemorySize;
+	m_capabilities.m_maxDrawIndirectCount = m_devProps.properties.limits.maxDrawIndirectCount;
 
 	m_capabilities.m_majorApiVersion = vulkanMajor;
 	m_capabilities.m_minorApiVersion = vulkanMinor;
@@ -784,6 +785,11 @@ Error GrManagerImpl::initDevice()
 				m_extensions |= VulkanExtensions::kKHR_maintenance_4;
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
+			else if(extensionName == VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::kKHR_draw_indirect_count;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
 		}
 
 		ANKI_VK_LOGI("Will enable the following device extensions:");
@@ -1097,6 +1103,12 @@ Error GrManagerImpl::initDevice()
 		ci.pNext = &maintenance4Features;
 	}
 
+	if(!(m_extensions & VulkanExtensions::kKHR_draw_indirect_count) || m_capabilities.m_maxDrawIndirectCount < kMaxU32)
+	{
+		ANKI_VK_LOGE(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME " not supported or too small maxDrawIndirectCount");
+		return Error::kFunctionFailed;
+	}
+
 	ANKI_VK_CHECK(vkCreateDevice(m_physicalDevice, &ci, nullptr, &m_device));
 
 	// Get VK_AMD_shader_info entry points
@@ -1338,7 +1350,7 @@ void GrManagerImpl::flushCommandBuffer(MicroCommandBufferPtr cmdb, Bool cmdbRend
 
 	// Command buffer
 	const VkCommandBuffer handle = cmdb->getHandle();
-	cmdb->setFence(fence);
+	cmdb->setFence(fence.get());
 	submit.commandBufferCount = 1;
 	submit.pCommandBuffers = &handle;
 
@@ -1368,7 +1380,7 @@ void GrManagerImpl::flushCommandBuffer(MicroCommandBufferPtr cmdb, Bool cmdbRend
 		++submit.waitSemaphoreCount;
 
 		// Refresh the fence because the semaphore can't be recycled until the current submission is done
-		userWaitSemaphore->setFence(fence);
+		userWaitSemaphore->setFence(fence.get());
 	}
 
 	if(userSignalSemaphore)
@@ -1399,7 +1411,7 @@ void GrManagerImpl::flushCommandBuffer(MicroCommandBufferPtr cmdb, Bool cmdbRend
 			++submit.waitSemaphoreCount;
 
 			// Refresh the fence because the semaphore can't be recycled until the current submission is done
-			frame.m_acquireSemaphore->setFence(fence);
+			frame.m_acquireSemaphore->setFence(fence.get());
 
 			// Create the semaphore to signal
 			ANKI_ASSERT(!frame.m_renderSemaphore && "Only one begin/end render pass is allowed with the default fb");
@@ -1411,7 +1423,7 @@ void GrManagerImpl::flushCommandBuffer(MicroCommandBufferPtr cmdb, Bool cmdbRend
 			frame.m_presentFence = fence;
 
 			// Update the swapchain's fence
-			m_crntSwapchain->setFence(fence);
+			m_crntSwapchain->setFence(fence.get());
 
 			frame.m_queueWroteToSwapchainImage = cmdb->getVulkanQueueType();
 		}

AnKi/Gr/Vulkan/MicroObjectRecycler.inl.h

@@ -104,7 +104,7 @@ void MicroObjectRecycler<T>::checkDoneFences()
 
 		if(!obj.m_fenceDone && mobj.getFence() && mobj.getFence()->done())
 		{
-			mobj.getFence().reset(nullptr);
+			mobj.setFence(nullptr);
 			mobj.onFenceDone();
 			obj.m_fenceDone = true;
 		}

AnKi/Gr/Vulkan/SemaphoreFactory.h

@@ -49,9 +49,9 @@ public:
 		return m_refcount.load();
 	}
 
-	MicroFencePtr& getFence()
+	MicroFence* getFence() const
 	{
-		return m_fence;
+		return m_fence.tryGet();
 	}
 
 	/// Interface method.
@@ -60,9 +60,9 @@ public:
 		// Do nothing
 	}
 
-	void setFence(MicroFencePtr& fence)
+	void setFence(MicroFence* fence)
 	{
-		m_fence = fence;
+		m_fence.reset(fence);
 	}
 
 	Bool clientWait(Second seconds);

AnKi/Gr/Vulkan/ShaderProgramImpl.cpp

@@ -43,7 +43,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 	}
 	else if(inf.m_graphicsShaders[ShaderType::kVertex])
 	{
-		for(const ShaderPtr& s : inf.m_graphicsShaders)
+		for(Shader* s : inf.m_graphicsShaders)
 		{
 			if(s)
 			{
@@ -58,12 +58,12 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 		m_shaders.resizeStorage(inf.m_rayTracingShaders.m_rayGenShaders.getSize() + inf.m_rayTracingShaders.m_missShaders.getSize()
 								+ 1); // Plus at least one hit shader
 
-		for(const ShaderPtr& s : inf.m_rayTracingShaders.m_rayGenShaders)
+		for(Shader* s : inf.m_rayTracingShaders.m_rayGenShaders)
 		{
 			m_shaders.emplaceBack(s);
 		}
 
-		for(const ShaderPtr& s : inf.m_rayTracingShaders.m_missShaders)
+		for(Shader* s : inf.m_rayTracingShaders.m_missShaders)
 		{
 			m_shaders.emplaceBack(s);
 		}

AnKi/Gr/Vulkan/SwapchainFactory.h

@@ -47,14 +47,14 @@ public:
 		return m_refcount.load();
 	}
 
-	void setFence(MicroFencePtr fence)
+	void setFence(MicroFence* fence)
 	{
-		m_fence = fence;
+		m_fence.reset(fence);
 	}
 
-	MicroFencePtr& getFence()
+	MicroFence* getFence() const
 	{
-		return m_fence;
+		return m_fence.tryGet();
 	}
 
 	/// Interface method.

AnKi/Gr/Vulkan/TextureViewImpl.cpp

@@ -20,7 +20,7 @@ Error TextureViewImpl::init(const TextureViewInitInfo& inf)
 	// Store some stuff
 	m_subresource = inf;
 
-	m_tex = inf.m_texture;
+	m_tex.reset(inf.m_texture);
 	const TextureImpl& tex = static_cast<const TextureImpl&>(*m_tex);
 	ANKI_ASSERT(tex.isSubresourceValid(inf));
 

AnKi/Renderer/AccelerationStructureBuilder.cpp

@@ -51,11 +51,11 @@ void AccelerationStructureBuilder::populateRenderGraph(RenderingContext& ctx)
 
 	// Build the job
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
-	m_runCtx.m_tlasHandle = rgraph.importAccelerationStructure(m_runCtx.m_tlas, AccelerationStructureUsageBit::kNone);
+	m_runCtx.m_tlasHandle = rgraph.importAccelerationStructure(m_runCtx.m_tlas.get(), AccelerationStructureUsageBit::kNone);
 	ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("BuildTlas");
 	rpass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 		ANKI_TRACE_SCOPED_EVENT(RTlas);
-		rgraphCtx.m_commandBuffer->buildAccelerationStructure(m_runCtx.m_tlas);
+		rgraphCtx.m_commandBuffer->buildAccelerationStructure(m_runCtx.m_tlas.get());
 	});
 
 	rpass.newAccelerationStructureDependency(m_runCtx.m_tlasHandle, AccelerationStructureUsageBit::kBuild);

AnKi/Renderer/Bloom.cpp

@@ -54,7 +54,7 @@ Error Bloom::initExposure()
 
 	const ShaderProgramResourceVariant* variant;
 	m_exposure.m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_exposure.m_grProg = variant->getProgram();
+	m_exposure.m_grProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -82,7 +82,7 @@ Error Bloom::initUpscale()
 
 	const ShaderProgramResourceVariant* variant;
 	m_upscale.m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_upscale.m_grProg = variant->getProgram();
+	m_upscale.m_grProg.reset(&variant->getProgram());
 
 	// Textures
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("EngineAssets/LensDirt.ankitex", m_upscale.m_lensDirtImage));
@@ -128,12 +128,12 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_exposure.m_grProg);
+			cmdb->bindShaderProgram(m_exposure.m_grProg.get());
 
 			TextureSubresourceInfo inputTexSubresource;
 			inputTexSubresource.m_firstMipmap = getRenderer().getDownscaleBlur().getMipmapCount() - 1;
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+			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);
@@ -151,7 +151,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			{
 				cmdb->setViewport(0, 0, m_exposure.m_width, m_exposure.m_height);
 
-				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+				cmdb->draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}
@@ -186,11 +186,11 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_upscale.m_grProg);
+			cmdb->bindShaderProgram(m_upscale.m_grProg.get());
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+			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())
 			{
@@ -202,7 +202,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			{
 				cmdb->setViewport(0, 0, m_upscale.m_width, m_upscale.m_height);
 
-				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+				cmdb->draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}

AnKi/Renderer/ClusterBinning.cpp

@@ -41,7 +41,7 @@ Error ClusterBinning::init()
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	m_tileCount = getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y();
 	m_clusterCount = m_tileCount + getRenderer().getZSplitCount();
@@ -54,7 +54,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	m_runCtx.m_ctx = &ctx;
 	writeClustererBuffers(ctx);
 
-	m_runCtx.m_rebarHandle = ctx.m_renderGraphDescr.importBuffer(RebarTransientMemoryPool::getSingleton().getBuffer(), BufferUsageBit::kNone,
+	m_runCtx.m_rebarHandle = ctx.m_renderGraphDescr.importBuffer(&RebarTransientMemoryPool::getSingleton().getBuffer(), BufferUsageBit::kNone,
 																 m_runCtx.m_clustersToken.m_offset, m_runCtx.m_clustersToken.m_range);
 
 	const RenderQueue& rqueue = *ctx.m_renderQueue;
@@ -75,7 +75,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg);
+		cmdb->bindShaderProgram(m_grProg.get());
 
 		bindUniforms(cmdb, 0, 0, m_runCtx.m_clusteredShadingUniformsToken);
 		bindStorage(cmdb, 0, 1, m_runCtx.m_clustersToken);

AnKi/Renderer/Dbg.cpp

@@ -64,7 +64,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 	cmdb->setDepthWrite(false);
 
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 	rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
@@ -140,8 +140,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			m_drawer.drawCubes(ConstWeakArray<Mat4>(&mvp, 1), Vec4(0.729f, 0.635f, 0.196f, 1.0f), 1.0f, m_ditheredDepthTestOn, 2.0f, cmdb);
 
 			m_drawer.drawBillboardTextures(ctx.m_matrices.m_projection, ctx.m_matrices.m_view, ConstWeakArray<Vec3>(&tsl, 1), Vec4(1.0f),
-										   m_ditheredDepthTestOn, m_giProbeImage->getTextureView(),
-										   getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										   m_ditheredDepthTestOn, &m_giProbeImage->getTextureView(),
+										   getRenderer().getSamplers().m_trilinearRepeatAniso.get(), Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -154,7 +154,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			color /= max(max(color.x(), color.y()), color.z());
 
 			m_drawer.drawBillboardTexture(ctx.m_matrices.m_projection, ctx.m_matrices.m_view, el.m_worldPosition, color.xyz1(), m_ditheredDepthTestOn,
-										  m_pointLightImage->getTextureView(), getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										  &m_pointLightImage->getTextureView(), getRenderer().getSamplers().m_trilinearRepeatAniso.get(), Vec2(0.75f),
+										  cmdb);
 		}
 
 		for(const SpotLightQueueElement& el : ctx.m_renderQueue->m_spotLights)
@@ -163,8 +164,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			color /= max(max(color.x(), color.y()), color.z());
 
 			m_drawer.drawBillboardTexture(ctx.m_matrices.m_projection, ctx.m_matrices.m_view, el.m_worldTransform.getTranslationPart().xyz(),
-										  color.xyz1(), m_ditheredDepthTestOn, m_spotLightImage->getTextureView(),
-										  getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										  color.xyz1(), m_ditheredDepthTestOn, &m_spotLightImage->getTextureView(),
+										  getRenderer().getSamplers().m_trilinearRepeatAniso.get(), Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -188,8 +189,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 			const Vec3 pos = el.m_obbCenter;
 			m_drawer.drawBillboardTextures(ctx.m_matrices.m_projection, ctx.m_matrices.m_view, ConstWeakArray<Vec3>(&pos, 1), Vec4(1.0f),
-										   m_ditheredDepthTestOn, m_decalImage->getTextureView(), getRenderer().getSamplers().m_trilinearRepeatAniso,
-										   Vec2(0.75f), cmdb);
+										   m_ditheredDepthTestOn, &m_decalImage->getTextureView(),
+										   getRenderer().getSamplers().m_trilinearRepeatAniso.get(), Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -212,8 +213,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			m_drawer.drawCubes(ConstWeakArray<Mat4>(&mvp, 1), Vec4(0.0f, 0.0f, 1.0f, 1.0f), 1.0f, m_ditheredDepthTestOn, 2.0f, cmdb);
 
 			m_drawer.drawBillboardTextures(ctx.m_matrices.m_projection, ctx.m_matrices.m_view, ConstWeakArray<Vec3>(&el.m_worldPosition, 1),
-										   Vec4(1.0f), m_ditheredDepthTestOn, m_reflectionImage->getTextureView(),
-										   getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										   Vec4(1.0f), m_ditheredDepthTestOn, &m_reflectionImage->getTextureView(),
+										   getRenderer().getSamplers().m_trilinearRepeatAniso.get(), Vec2(0.75f), cmdb);
 		}
 	}
 

AnKi/Renderer/DebugDrawer.cpp

@@ -156,19 +156,19 @@ 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->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->bindVertexBuffer(0, m_cubePositionsBuffer, 0, sizeof(Vec3));
-	cmdb->bindIndexBuffer(m_cubeIndicesBuffer, 0, IndexType::kU16);
+	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);
 	constexpr U kIndexCount = 12 * 2;
-	cmdb->drawElements(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,
@@ -193,22 +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->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->bindVertexBuffer(0, RebarTransientMemoryPool::getSingleton().getBuffer(), vertsToken.m_offset, sizeof(Vec3));
+	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->drawArrays(PrimitiveTopology::kLines, linePositions.getSize(), mvps.getSize());
+	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, TextureViewPtr tex, SamplerPtr sampler, Vec2 billboardSize,
-										 CommandBufferPtr& cmdb) const
+										 Bool ditherFailedDepth, TextureView* tex, Sampler* sampler, Vec2 billboardSize, CommandBufferPtr& cmdb) const
 {
 	RebarAllocation positionsToken;
 	Vec3* verts = static_cast<Vec3*>(RebarTransientMemoryPool::getSingleton().allocateFrame(sizeof(Vec3) * 4, positionsToken));
@@ -257,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->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->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->bindStorageBuffer(0, 0, &RebarTransientMemoryPool::getSingleton().getBuffer(), unisToken.m_offset, unisToken.m_range);
 	cmdb->bindSampler(0, 3, sampler);
 	cmdb->bindTexture(0, 4, tex);
 
-	cmdb->drawArrays(PrimitiveTopology::kTriangleStrip, 4, positions.getSize());
+	cmdb->draw(PrimitiveTopology::kTriangleStrip, 4, positions.getSize());
 }
 
 void PhysicsDebugDrawer::drawLines(const Vec3* lines, const U32 vertCount, const Vec4& color)

AnKi/Renderer/DebugDrawer.h

@@ -54,10 +54,10 @@ public:
 	}
 
 	void drawBillboardTextures(const Mat4& projMat, const Mat3x4& viewMat, ConstWeakArray<Vec3> positions, const Vec4& color, Bool ditherFailedDepth,
-							   TextureViewPtr tex, SamplerPtr sampler, Vec2 billboardSize, CommandBufferPtr& cmdb) const;
+							   TextureView* tex, Sampler* sampler, Vec2 billboardSize, CommandBufferPtr& cmdb) const;
 
-	void drawBillboardTexture(const Mat4& projMat, const Mat3x4& viewMat, Vec3 position, const Vec4& color, Bool ditherFailedDepth,
-							  TextureViewPtr tex, SamplerPtr sampler, Vec2 billboardSize, CommandBufferPtr& 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
 	{
 		drawBillboardTextures(projMat, viewMat, ConstWeakArray<Vec3>(&position, 1), color, ditherFailedDepth, tex, sampler, billboardSize, cmdb);
 	}

AnKi/Renderer/DepthDownscale.cpp

@@ -77,7 +77,7 @@ Error DepthDownscale::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_grProg = variant->getProgram();
+		m_grProg.reset(&variant->getProgram());
 	}
 	else
 	{
@@ -88,12 +88,12 @@ Error DepthDownscale::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_grProg = variant->getProgram();
+		m_grProg.reset(&variant->getProgram());
 
 		// 1st mip prog
 		variantInitInfo.addMutation("REDUCTION_SAMPLER", 1);
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_firstMipGrProg = variant->getProgram();
+		m_firstMipGrProg.reset(&variant->getProgram());
 	}
 
 	// Counter buffer
@@ -166,11 +166,11 @@ void DepthDownscale::importRenderTargets(RenderingContext& ctx)
 	// Import RT
 	if(m_hizTexImportedOnce)
 	{
-		m_runCtx.m_hizRt = rgraph.importRenderTarget(m_hizTex);
+		m_runCtx.m_hizRt = rgraph.importRenderTarget(m_hizTex.get());
 	}
 	else
 	{
-		m_runCtx.m_hizRt = rgraph.importRenderTarget(m_hizTex, TextureUsageBit::kSampledFragment);
+		m_runCtx.m_hizRt = rgraph.importRenderTarget(m_hizTex.get(), TextureUsageBit::kSampledFragment);
 		m_hizTexImportedOnce = true;
 	}
 }
@@ -241,14 +241,14 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 	{
 		m_counterBufferZeroed = true;
 
-		cmdb->fillBuffer(m_counterBuffer, 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->bindShaderProgram(m_grProg);
+	cmdb->bindShaderProgram(m_grProg.get());
 
 	varAU2(dispatchThreadGroupCountXY);
 	varAU2(workGroupOffset); // needed if Left and Top are not 0,0
@@ -295,10 +295,10 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 		rgraphCtx.bindImage(0, 1, m_runCtx.m_hizRt, subresource);
 	}
 
-	cmdb->bindStorageBuffer(0, 2, m_counterBuffer, 0, kMaxPtrSize);
-	cmdb->bindStorageBuffer(0, 3, m_clientBuffer, 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);
+	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);
@@ -312,9 +312,9 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 	{
 		rgraphCtx.bindTexture(0, 0, getRenderer().getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 
-		cmdb->bindShaderProgram(m_firstMipGrProg);
+		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);
+			cmdb->bindSampler(0, 1, m_reductionSampler.get());
 		}
 		else
 		{
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp.get());
 		}
 
-		cmdb->bindShaderProgram(m_grProg);
+		cmdb->bindShaderProgram(m_grProg.get());
 	}
 
-	cmdb->bindStorageBuffer(0, 2, m_clientBuffer, 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));
 
 	const UVec2 size = (getRenderer().getInternalResolution() / 2) >> mip;
 	cmdb->setViewport(0, 0, size.x(), size.y());
-	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+	cmdb->draw(PrimitiveTopology::kTriangles, 3);
 }
 
 } // end namespace anki

AnKi/Renderer/DownscaleBlur.cpp

@@ -63,7 +63,7 @@ Error DownscaleBlur::initInternal()
 		(preferCompute) ? "ShaderBinaries/DownscaleBlurCompute.ankiprogbin" : "ShaderBinaries/DownscaleBlurRaster.ankiprogbin", m_prog));
 	const ShaderProgramResourceVariant* variant = nullptr;
 	m_prog->getOrCreateVariant(variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -71,7 +71,7 @@ Error DownscaleBlur::initInternal()
 void DownscaleBlur::importRenderTargets(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
-	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex, TextureUsageBit::kSampledCompute);
+	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex.get(), TextureUsageBit::kSampledCompute);
 }
 
 void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
@@ -148,12 +148,12 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg);
+	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);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 
 	if(passIdx > 0)
 	{
@@ -186,7 +186,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	{
 		cmdb->setViewport(0, 0, vpWidth, vpHeight);
 
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/Drawer.cpp

@@ -51,22 +51,22 @@ void RenderableDrawer::drawRange(const RenderableDrawerArguments& args, const Re
 		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);
+								&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->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);
+									&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->bindIndexBuffer(&UnifiedGeometryBuffer::getSingleton().getBuffer(), 0, IndexType::kU16);
 
 	// Set a few things
 	Context ctx;
@@ -99,7 +99,7 @@ void RenderableDrawer::flushDrawcall(Context& ctx)
 		instances[i] = packGpuSceneRenderable(renderable);
 	}
 
-	cmdb->bindVertexBuffer(0, RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, sizeof(GpuSceneRenderablePacked),
+	cmdb->bindVertexBuffer(0, &RebarTransientMemoryPool::getSingleton().getBuffer(), token.m_offset, sizeof(GpuSceneRenderablePacked),
 						   VertexStepRate::kInstance);
 
 	// Set state
@@ -107,17 +107,17 @@ void RenderableDrawer::flushDrawcall(Context& ctx)
 
 	if(firstElement.m_program != ctx.m_lastBoundShaderProgram)
 	{
-		cmdb->bindShaderProgram(ShaderProgramPtr(firstElement.m_program));
+		cmdb->bindShaderProgram(firstElement.m_program);
 		ctx.m_lastBoundShaderProgram = firstElement.m_program;
 	}
 
 	if(firstElement.m_indexed)
 	{
-		cmdb->drawElements(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->drawArrays(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

AnKi/Renderer/Drawer.h

@@ -28,7 +28,7 @@ public:
 	Mat4 m_viewProjectionMatrix;
 	Mat4 m_previousViewProjectionMatrix;
 
-	SamplerPtr m_sampler;
+	Sampler* m_sampler;
 };
 
 /// It uses the render queue to batch and render.

AnKi/Renderer/FinalComposite.cpp

@@ -43,13 +43,13 @@ Error FinalComposite::initInternal()
 		const ShaderProgramResourceVariant* variant;
 		variantInitInfo.addMutation("DBG_ENABLED", dbg);
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_grProgs[dbg] = variant->getProgram();
+		m_grProgs[dbg].reset(&variant->getProgram());
 	}
 
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/VisualizeRenderTarget.ankiprogbin", m_defaultVisualizeRenderTargetProg));
 	const ShaderProgramResourceVariant* variant;
 	m_defaultVisualizeRenderTargetProg->getOrCreateVariant(variant);
-	m_defaultVisualizeRenderTargetGrProg = variant->getProgram();
+	m_defaultVisualizeRenderTargetGrProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -127,28 +127,28 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 	// Bind program
 	if(hasDebugRt && optionalDebugProgram.isCreated())
 	{
-		cmdb->bindShaderProgram(optionalDebugProgram);
+		cmdb->bindShaderProgram(optionalDebugProgram.get());
 	}
 	else if(hasDebugRt)
 	{
-		cmdb->bindShaderProgram(m_defaultVisualizeRenderTargetGrProg);
+		cmdb->bindShaderProgram(m_defaultVisualizeRenderTargetGrProg.get());
 	}
 	else
 	{
-		cmdb->bindShaderProgram(m_grProgs[dbgEnabled]);
+		cmdb->bindShaderProgram(m_grProgs[dbgEnabled].get());
 	}
 
 	// Bind stuff
 	if(!hasDebugRt)
 	{
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
-		cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat);
+		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));
 
@@ -162,7 +162,7 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 	}
 	else
 	{
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 		U32 count = 1;
 		for(const RenderTargetHandle& handle : dbgRts)

AnKi/Renderer/ForwardShading.cpp

@@ -34,8 +34,8 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 		cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 
 		const U32 set = U32(MaterialSet::kGlobal);
-		cmdb->bindSampler(set, U32(MaterialBinding::kLinearClampSampler), getRenderer().getSamplers().m_trilinearClamp);
-		cmdb->bindSampler(set, U32(MaterialBinding::kShadowSampler), getRenderer().getSamplers().m_trilinearClampShadow);
+		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());
@@ -53,7 +53,7 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 		args.m_cameraTransform = ctx.m_matrices.m_cameraTransform;
 		args.m_viewProjectionMatrix = ctx.m_matrices.m_viewProjectionJitter;
 		args.m_previousViewProjectionMatrix = ctx.m_prevMatrices.m_viewProjectionJitter; // Not sure about that
-		args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias;
+		args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias.get();
 
 		// Start drawing
 		getRenderer().getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + start,

AnKi/Renderer/GBuffer.cpp

@@ -126,7 +126,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	args.m_cameraTransform = ctx.m_matrices.m_cameraTransform;
 	args.m_viewProjectionMatrix = ctx.m_matrices.m_viewProjectionJitter;
 	args.m_previousViewProjectionMatrix = ctx.m_matrices.m_jitter * ctx.m_prevMatrices.m_viewProjection;
-	args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias;
+	args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias.get();
 
 	// First do early Z (if needed)
 	if(earlyZStart < earlyZEnd)
@@ -168,14 +168,14 @@ void GBuffer::importRenderTargets(RenderingContext& ctx)
 	if(m_runCtx.m_crntFrameDepthRt.isValid()) [[likely]]
 	{
 		// Already imported once
-		m_runCtx.m_crntFrameDepthRt = rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1], TextureUsageBit::kNone);
-		m_runCtx.m_prevFrameDepthRt = rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1]);
+		m_runCtx.m_crntFrameDepthRt = rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1].get(), TextureUsageBit::kNone);
+		m_runCtx.m_prevFrameDepthRt = rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1].get());
 	}
 	else
 	{
-		m_runCtx.m_crntFrameDepthRt = rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1], TextureUsageBit::kNone);
+		m_runCtx.m_crntFrameDepthRt = rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1].get(), TextureUsageBit::kNone);
 		m_runCtx.m_prevFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1], TextureUsageBit::kSampledFragment);
+			rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1].get(), TextureUsageBit::kSampledFragment);
 	}
 }
 

AnKi/Renderer/GBufferPost.cpp

@@ -36,7 +36,7 @@ Error GBufferPost::initInternal()
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	// Create FB descr
 	m_fbDescr.m_colorAttachmentCount = 2;
@@ -78,17 +78,17 @@ void GBufferPost::run(RenderPassWorkContext& rgraphCtx)
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
-	cmdb->bindShaderProgram(m_grProg);
+	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);
 
 	// Bind all
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	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);
+	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
 	bindUniforms(cmdb, 0, 3, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 
@@ -99,7 +99,7 @@ void GBufferPost::run(RenderPassWorkContext& rgraphCtx)
 	cmdb->bindAllBindless(1);
 
 	// Draw
-	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+	cmdb->draw(PrimitiveTopology::kTriangles, 3);
 
 	// Restore state
 	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kZero);

AnKi/Renderer/GpuVisibility.cpp

@@ -41,11 +41,11 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 	memset(atomics, 0, mdiDrawCounts.m_range);
 
 	// Import buffers
-	m_runCtx.m_instanceRateRenderables = rgraph.importBuffer(BufferPtr(instanceRateRenderables.m_buffer), BufferUsageBit::kNone,
+	m_runCtx.m_instanceRateRenderables = rgraph.importBuffer(instanceRateRenderables.m_buffer, BufferUsageBit::kNone,
 															 instanceRateRenderables.m_offset, instanceRateRenderables.m_size);
 	m_runCtx.m_drawIndexedIndirectArgs =
-		rgraph.importBuffer(BufferPtr(indirectArgs.m_buffer), BufferUsageBit::kNone, indirectArgs.m_offset, indirectArgs.m_size);
-	m_runCtx.m_mdiDrawCounts = rgraph.importBuffer(RebarTransientMemoryPool::getSingleton().getBuffer(), BufferUsageBit::kNone,
+		rgraph.importBuffer(indirectArgs.m_buffer, BufferUsageBit::kNone, indirectArgs.m_offset, indirectArgs.m_size);
+	m_runCtx.m_mdiDrawCounts = rgraph.importBuffer(&RebarTransientMemoryPool::getSingleton().getBuffer(), BufferUsageBit::kNone,
 												   mdiDrawCounts.m_offset, mdiDrawCounts.m_range);
 
 	// Create the renderpass
@@ -61,20 +61,20 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 	pass.setWork([this, &ctx](RenderPassWorkContext& rpass) {
 		CommandBufferPtr& cmdb = rpass.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg);
+		cmdb->bindShaderProgram(m_grProg.get());
 
 		cmdb->bindStorageBuffer(
-			0, 0, GpuSceneBuffer::getSingleton().getBuffer(),
+			0, 0, &GpuSceneBuffer::getSingleton().getBuffer(),
 			GpuSceneContiguousArrays::getSingleton().getArrayBase(GpuSceneContiguousArrayType::kRenderableBoundingVolumesGBuffer),
 			GpuSceneContiguousArrays::getSingleton().getElementCount(GpuSceneContiguousArrayType::kRenderableBoundingVolumesGBuffer)
 				* sizeof(GpuSceneRenderableAabb));
 
-		cmdb->bindStorageBuffer(0, 1, GpuSceneBuffer::getSingleton().getBuffer(),
+		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());
 

AnKi/Renderer/HiZ.cpp

@@ -35,18 +35,18 @@ Error HiZ::init()
 
 	const ShaderProgramResourceVariant* variant;
 	m_reproj.m_prog->getOrCreateVariant(variant);
-	m_reproj.m_grProg = variant->getProgram();
+	m_reproj.m_grProg.reset(&variant->getProgram());
 
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ClearTextureCompute.ankiprogbin", m_clearHiZ.m_prog));
 	ShaderProgramResourceVariantInitInfo variantInit(m_clearHiZ.m_prog);
 	variantInit.addMutation("TEXTURE_DIMENSIONS", 2);
 	variantInit.addMutation("COMPONENT_TYPE", 1);
 	m_clearHiZ.m_prog->getOrCreateVariant(variantInit, variant);
-	m_clearHiZ.m_grProg = variant->getProgram();
+	m_clearHiZ.m_grProg.reset(&variant->getProgram());
 
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/HiZGenPyramid.ankiprogbin", m_mipmapping.m_prog));
 	m_mipmapping.m_prog->getOrCreateVariant(variant);
-	m_mipmapping.m_grProg = variant->getProgram();
+	m_mipmapping.m_grProg.reset(&variant->getProgram());
 
 	m_hiZRtDescr = getRenderer().create2DRenderTargetDescription(ConfigSet::getSingleton().getRHiZWidth(), ConfigSet::getSingleton().getRHiZHeight(),
 																 Format::kR32_Uint, "HiZ U32");
@@ -76,7 +76,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 		pass.setWork([this](RenderPassWorkContext& rctx) {
 			CommandBufferPtr& cmdb = rctx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_clearHiZ.m_grProg);
+			cmdb->bindShaderProgram(m_clearHiZ.m_grProg.get());
 
 			TextureSubresourceInfo firstMipSubresource;
 			rctx.bindImage(0, 0, m_runCtx.m_hiZRt, firstMipSubresource);
@@ -97,7 +97,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 		pass.setWork([this, &ctx](RenderPassWorkContext& rctx) {
 			CommandBufferPtr& cmdb = rctx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_reproj.m_grProg);
+			cmdb->bindShaderProgram(m_reproj.m_grProg.get());
 
 			rctx.bindTexture(0, 0, getRenderer().getGBuffer().getPreviousFrameDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 			TextureSubresourceInfo firstMipSubresource;
@@ -133,14 +133,14 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 			{
 				m_mipmapping.m_counterBufferZeroed = true;
 
-				cmdb->fillBuffer(m_mipmapping.m_counterBuffer, 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->bindShaderProgram(m_mipmapping.m_grProg);
+			cmdb->bindShaderProgram(m_mipmapping.m_grProg.get());
 
 			varAU2(dispatchThreadGroupCountXY);
 			varAU2(workGroupOffset); // needed if Left and Top are not 0,0
@@ -191,7 +191,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 				rgraphCtx.bindImage(0, 1, m_runCtx.m_hiZRt, subresource);
 			}
 
-			cmdb->bindStorageBuffer(0, 2, m_mipmapping.m_counterBuffer, 0, kMaxPtrSize);
+			cmdb->bindStorageBuffer(0, 2, m_mipmapping.m_counterBuffer.get(), 0, kMaxPtrSize);
 
 			rgraphCtx.bindTexture(0, 3, m_runCtx.m_hiZRt, firstMipSubresource);
 

AnKi/Renderer/IndirectDiffuse.cpp

@@ -88,11 +88,11 @@ Error IndirectDiffuse::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_vrs.m_prog->getOrCreateVariant(variantInit, variant);
-		m_vrs.m_grProg = variant->getProgram();
+		m_vrs.m_grProg.reset(&variant->getProgram());
 
 		ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/VrsSriVisualizeRenderTarget.ankiprogbin", m_vrs.m_visualizeProg));
 		m_vrs.m_visualizeProg->getOrCreateVariant(variant);
-		m_vrs.m_visualizeGrProg = variant->getProgram();
+		m_vrs.m_visualizeGrProg.reset(&variant->getProgram());
 	}
 
 	// Init SSGI+probes pass
@@ -103,7 +103,7 @@ Error IndirectDiffuse::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_main.m_prog->getOrCreateVariant(variant);
-		m_main.m_grProg = variant->getProgram();
+		m_main.m_grProg.reset(&variant->getProgram());
 	}
 
 	// Init denoise
@@ -119,11 +119,11 @@ Error IndirectDiffuse::initInternal()
 		variantInit.addMutation("BLUR_ORIENTATION", 0);
 		const ShaderProgramResourceVariant* variant;
 		m_denoise.m_prog->getOrCreateVariant(variantInit, variant);
-		m_denoise.m_grProgs[0] = variant->getProgram();
+		m_denoise.m_grProgs[0].reset(&variant->getProgram());
 
 		variantInit.addMutation("BLUR_ORIENTATION", 1);
 		m_denoise.m_prog->getOrCreateVariant(variantInit, variant);
-		m_denoise.m_grProgs[1] = variant->getProgram();
+		m_denoise.m_grProgs[1].reset(&variant->getProgram());
 	}
 
 	return Error::kNone;
@@ -169,10 +169,10 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_vrs.m_grProg);
+			cmdb->bindShaderProgram(m_vrs.m_grProg.get());
 
 			rgraphCtx.bindTexture(0, 0, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
+			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp.get());
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_sriRt);
 
 			class
@@ -198,13 +198,13 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		const U32 writeRtIdx = !readRtIdx;
 		if(m_rtsImportedOnce) [[likely]]
 		{
-			m_runCtx.m_mainRtHandles[0] = rgraph.importRenderTarget(m_rts[readRtIdx]);
-			m_runCtx.m_mainRtHandles[1] = rgraph.importRenderTarget(m_rts[writeRtIdx]);
+			m_runCtx.m_mainRtHandles[0] = rgraph.importRenderTarget(m_rts[readRtIdx].get());
+			m_runCtx.m_mainRtHandles[1] = rgraph.importRenderTarget(m_rts[writeRtIdx].get());
 		}
 		else
 		{
-			m_runCtx.m_mainRtHandles[0] = rgraph.importRenderTarget(m_rts[readRtIdx], TextureUsageBit::kAllSampled);
-			m_runCtx.m_mainRtHandles[1] = rgraph.importRenderTarget(m_rts[writeRtIdx], TextureUsageBit::kAllSampled);
+			m_runCtx.m_mainRtHandles[0] = rgraph.importRenderTarget(m_rts[readRtIdx].get(), TextureUsageBit::kAllSampled);
+			m_runCtx.m_mainRtHandles[1] = rgraph.importRenderTarget(m_rts[writeRtIdx].get(), TextureUsageBit::kAllSampled);
 			m_rtsImportedOnce = true;
 		}
 
@@ -251,13 +251,13 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		prpass->setWork([this, &ctx, enableVrs](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-			cmdb->bindShaderProgram(m_main.m_grProg);
+			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);
+			cmdb->bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 4, getRenderer().getGBuffer().getColorRt(2));
 
 			TextureSubresourceInfo hizSubresource;
@@ -301,7 +301,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 					cmdb->setVrsRate(VrsRate::k1x1);
 				}
 
-				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+				cmdb->draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}
@@ -339,9 +339,9 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		prpass->setWork([this, &ctx, dir, readIdx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-			cmdb->bindShaderProgram(m_denoise.m_grProgs[dir]);
+			cmdb->bindShaderProgram(m_denoise.m_grProgs[dir].get());
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_mainRtHandles[readIdx]);
 			TextureSubresourceInfo hizSubresource;
 			hizSubresource.m_mipmapCount = 1;
@@ -369,7 +369,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 			{
 				cmdb->setViewport(0, 0, unis.m_viewportSize.x(), unis.m_viewportSize.y());
 
-				cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+				cmdb->draw(PrimitiveTopology::kTriangles, 3);
 			}
 		});
 	}

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -165,7 +165,7 @@ Error IndirectDiffuseProbes::initIrradiance()
 
 	const ShaderProgramResourceVariant* variant;
 	m_irradiance.m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_irradiance.m_grProg = variant->getProgram();
+	m_irradiance.m_grProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -304,8 +304,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 	// Irradiance pass. First & 2nd bounce
 	{
-		m_giCtx->m_irradianceVolume =
-			rgraph.importRenderTarget(TexturePtr(m_giCtx->m_probeToUpdateThisFrame->m_volumeTexture), TextureUsageBit::kNone);
+		m_giCtx->m_irradianceVolume = rgraph.importRenderTarget(m_giCtx->m_probeToUpdateThisFrame->m_volumeTexture, TextureUsageBit::kNone);
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("GI IR");
 
@@ -361,7 +360,7 @@ void IndirectDiffuseProbes::runGBufferInThread(RenderPassWorkContext& rgraphCtx,
 			args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 			args.m_viewProjectionMatrix = rqueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeat;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeat.get();
 
 			getRenderer().getSceneDrawer().drawRange(args, rqueue.m_renderables.getBegin() + localStart, rqueue.m_renderables.getBegin() + localEnd,
 													 cmdb);
@@ -417,7 +416,7 @@ void IndirectDiffuseProbes::runShadowmappingInThread(RenderPassWorkContext& rgra
 			args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 			args.m_viewProjectionMatrix = cascadeRenderQueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso.get();
 
 			getRenderer().getSceneDrawer().drawRange(args, cascadeRenderQueue.m_renderables.getBegin() + localStart,
 													 cascadeRenderQueue.m_renderables.getBegin() + localEnd, cmdb);
@@ -484,10 +483,10 @@ void IndirectDiffuseProbes::runIrradiance(RenderPassWorkContext& rgraphCtx, Inte
 	ANKI_ASSERT(giCtx.m_probeToUpdateThisFrame);
 	const GlobalIlluminationProbeQueueElementForRefresh& probe = *giCtx.m_probeToUpdateThisFrame;
 
-	cmdb->bindShaderProgram(m_irradiance.m_grProg);
+	cmdb->bindShaderProgram(m_irradiance.m_grProg.get());
 
 	// Bind resources
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, giCtx.m_lightShadingRt);
 
 	for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)

AnKi/Renderer/IndirectSpecular.cpp

@@ -61,7 +61,7 @@ Error IndirectSpecular::initInternal()
 	variantInit.addMutation("STOCHASTIC", ConfigSet::getSingleton().getRSsrStochastic());
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInit, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -78,13 +78,13 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 	const U32 writeRtIdx = !readRtIdx;
 	if(m_rtsImportedOnce) [[likely]]
 	{
-		m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rts[readRtIdx]);
-		m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rts[writeRtIdx]);
+		m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rts[readRtIdx].get());
+		m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rts[writeRtIdx].get());
 	}
 	else
 	{
-		m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rts[readRtIdx], TextureUsageBit::kAllSampled);
-		m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rts[writeRtIdx], TextureUsageBit::kAllSampled);
+		m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rts[readRtIdx].get(), TextureUsageBit::kAllSampled);
+		m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rts[writeRtIdx].get(), TextureUsageBit::kAllSampled);
 		m_rtsImportedOnce = true;
 	}
 
@@ -162,7 +162,7 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
-	cmdb->bindShaderProgram(m_grProg);
+	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);
+	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,8 +197,8 @@ 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);
-	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);
@@ -216,7 +216,7 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	{
 		cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2);
 
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/LensFlare.cpp

@@ -47,10 +47,7 @@ Error LensFlare::initSprite()
 	m_maxSprites = U16(m_maxSpritesPerFlare * m_maxFlares);
 
 	// Load prog
-	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/LensFlareSprite.ankiprogbin", m_realProg));
-	const ShaderProgramResourceVariant* variant;
-	m_realProg->getOrCreateVariant(variant);
-	m_realGrProg = variant->getProgram();
+	ANKI_CHECK(loadShaderProgram("ShaderBinaries/LensFlareSprite.ankiprogbin", m_realProg, m_realGrProg));
 
 	return Error::kNone;
 }
@@ -68,7 +65,7 @@ Error LensFlare::initOcclusion()
 								UVec2(getRenderer().getInternalResolution().x() / 2 / 2, getRenderer().getInternalResolution().y() / 2 / 2));
 	const ShaderProgramResourceVariant* variant;
 	m_updateIndirectBuffProg->getOrCreateVariant(variantInitInfo, variant);
-	m_updateIndirectBuffGrProg = variant->getProgram();
+	m_updateIndirectBuffGrProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -79,7 +76,7 @@ void LensFlare::updateIndirectInfo(const RenderingContext& ctx, RenderPassWorkCo
 	U32 count = min<U32>(ctx.m_renderQueue->m_lensFlares.getSize(), m_maxFlares);
 	ANKI_ASSERT(count > 0);
 
-	cmdb->bindShaderProgram(m_updateIndirectBuffGrProg);
+	cmdb->bindShaderProgram(m_updateIndirectBuffGrProg.get());
 
 	cmdb->setPushConstants(&ctx.m_matrices.m_viewProjectionJitter, sizeof(ctx.m_matrices.m_viewProjectionJitter));
 
@@ -93,7 +90,7 @@ 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);
+	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getHiZRt(), kHiZQuarterSurface);
 	cmdb->dispatchCompute(count, 1, 1);
 }
@@ -108,7 +105,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
 	// Import buffer
-	m_runCtx.m_indirectBuffHandle = rgraph.importBuffer(m_indirectBuff, BufferUsageBit::kNone);
+	m_runCtx.m_indirectBuffHandle = rgraph.importBuffer(m_indirectBuff.get(), BufferUsageBit::kNone);
 
 	// Update the indirect buffer
 	{
@@ -132,7 +129,7 @@ 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);
+	cmdb->bindShaderProgram(m_realGrProg.get());
 	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 	cmdb->setDepthWrite(false);
 
@@ -171,10 +168,10 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 
 		// Render
 		ANKI_ASSERT(flareEl.m_textureView);
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearRepeat);
-		cmdb->bindTexture(0, 2, TextureViewPtr(const_cast<TextureView*>(flareEl.m_textureView)));
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearRepeat.get());
+		cmdb->bindTexture(0, 2, flareEl.m_textureView);
 
-		cmdb->drawArraysIndirect(PrimitiveTopology::kTriangleStrip, 1, i * sizeof(DrawIndirectArgs), m_indirectBuff);
+		cmdb->drawIndirect(PrimitiveTopology::kTriangleStrip, 1, i * sizeof(DrawIndirectArgs), m_indirectBuff.get());
 	}
 
 	// Restore state

AnKi/Renderer/LightShading.cpp

@@ -65,11 +65,11 @@ Error LightShading::initLightShading()
 
 	variantInitInfo.addMutation("USE_SHADOW_LAYERS", 0);
 	m_lightShading.m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_lightShading.m_grProg[0] = variant->getProgram();
+	m_lightShading.m_grProg[0].reset(&variant->getProgram());
 
 	variantInitInfo.addMutation("USE_SHADOW_LAYERS", 1);
 	m_lightShading.m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_lightShading.m_grProg[1] = variant->getProgram();
+	m_lightShading.m_grProg[1].reset(&variant->getProgram());
 
 	// Create RT descr
 	const UVec2 internalResolution = getRenderer().getInternalResolution();
@@ -108,7 +108,7 @@ Error LightShading::initSkybox()
 		const ShaderProgramResourceVariant* variant;
 		m_skybox.m_prog->getOrCreateVariant(variantInitInfo, variant);
 
-		m_skybox.m_grProgs[method] = variant->getProgram();
+		m_skybox.m_grProgs[method].reset(&variant->getProgram());
 	}
 
 	return Error::kNone;
@@ -125,7 +125,7 @@ Error LightShading::initApplyFog()
 
 	const ShaderProgramResourceVariant* variant;
 	m_applyFog.m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_applyFog.m_grProg = variant->getProgram();
+	m_applyFog.m_grProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -152,7 +152,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 	// Do light shading first
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
-		cmdb->bindShaderProgram(m_lightShading.m_grProg[getRenderer().getRtShadowsEnabled()]);
+		cmdb->bindShaderProgram(m_lightShading.m_grProg[getRenderer().getRtShadowsEnabled()].get());
 		cmdb->setDepthWrite(false);
 
 		// Bind all
@@ -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);
-		cmdb->bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClamp);
+		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));
@@ -188,10 +188,10 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
 		cmdb->setDepthWrite(false);
-		cmdb->bindShaderProgram(m_applyIndirect.m_grProg);
+		cmdb->bindShaderProgram(m_applyIndirect.m_grProg.get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+		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,7 +199,7 @@ 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());
 
@@ -223,14 +223,14 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 
 		if(isSolidColor)
 		{
-			cmdb->bindShaderProgram(m_skybox.m_grProgs[0]);
+			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));
 		}
 		else
 		{
-			cmdb->bindShaderProgram(m_skybox.m_grProgs[1]);
+			cmdb->bindShaderProgram(m_skybox.m_grProgs[1].get());
 
 			class
 			{
@@ -245,8 +245,8 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 
 			cmdb->setPushConstants(&pc, sizeof(pc));
 
-			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias);
-			cmdb->bindTexture(0, 1, TextureViewPtr(const_cast<TextureView*>(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);
@@ -258,11 +258,11 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 	// Do the fog apply
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == rgraphCtx.m_secondLevelCommandBufferCount - 1u)
 	{
-		cmdb->bindShaderProgram(m_applyFog.m_grProg);
+		cmdb->bindShaderProgram(m_applyFog.m_grProg.get());
 
 		// Bind all
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+		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());

AnKi/Renderer/MainRenderer.cpp

@@ -53,7 +53,7 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 		ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/BlitRaster.ankiprogbin", m_blitProg));
 		const ShaderProgramResourceVariant* variant;
 		m_blitProg->getOrCreateVariant(variant);
-		m_blitGrProg = variant->getProgram();
+		m_blitGrProg.reset(&variant->getProgram());
 
 		// The RT desc
 		UVec2 resolution = UVec2(Vec2(m_swapchainResolution) * ConfigSet::getSingleton().getRRenderScaling());
@@ -77,7 +77,7 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 	return Error::kNone;
 }
 
-Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
+Error MainRenderer::render(RenderQueue& rqueue, Texture* presentTex)
 {
 	ANKI_TRACE_SCOPED_EVENT(Render);
 
@@ -118,11 +118,11 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 			cmdb->setViewport(0, 0, m_swapchainResolution.x(), m_swapchainResolution.y());
 
-			cmdb->bindShaderProgram(m_blitGrProg);
-			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
+			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->drawArrays(PrimitiveTopology::kTriangles, 3);
+			cmdb->draw(PrimitiveTopology::kTriangles, 3);
 		});
 
 		pass.newTextureDependency(presentRt, TextureUsageBit::kFramebufferWrite);

AnKi/Renderer/MainRenderer.h

@@ -41,7 +41,7 @@ class MainRenderer : public MakeSingleton<MainRenderer>
 public:
 	Error init(const MainRendererInitInfo& inf);
 
-	Error render(RenderQueue& rqueue, TexturePtr presentTex);
+	Error render(RenderQueue& rqueue, Texture* presentTex);
 
 	Dbg& getDbg();
 

AnKi/Renderer/MotionVectors.cpp

@@ -33,7 +33,7 @@ Error MotionVectors::initInternal()
 	variantInitInfo.addConstant("kFramebufferSize", UVec2(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y()));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	// RTs
 	m_motionVectorsRtDescr = getRenderer().create2DRenderTargetDescription(
@@ -74,14 +74,15 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 
 	if(m_historyLengthTexturesImportedOnce) [[likely]]
 	{
-		m_runCtx.m_historyLengthWriteRtHandle = rgraph.importRenderTarget(m_historyLengthTextures[writeHistoryLenTexIdx]);
-		m_runCtx.m_historyLengthReadRtHandle = rgraph.importRenderTarget(m_historyLengthTextures[readHistoryLenTexIdx]);
+		m_runCtx.m_historyLengthWriteRtHandle = rgraph.importRenderTarget(m_historyLengthTextures[writeHistoryLenTexIdx].get());
+		m_runCtx.m_historyLengthReadRtHandle = rgraph.importRenderTarget(m_historyLengthTextures[readHistoryLenTexIdx].get());
 	}
 	else
 	{
 		m_runCtx.m_historyLengthWriteRtHandle =
-			rgraph.importRenderTarget(m_historyLengthTextures[writeHistoryLenTexIdx], TextureUsageBit::kAllSampled);
-		m_runCtx.m_historyLengthReadRtHandle = rgraph.importRenderTarget(m_historyLengthTextures[readHistoryLenTexIdx], TextureUsageBit::kAllSampled);
+			rgraph.importRenderTarget(m_historyLengthTextures[writeHistoryLenTexIdx].get(), TextureUsageBit::kAllSampled);
+		m_runCtx.m_historyLengthReadRtHandle =
+			rgraph.importRenderTarget(m_historyLengthTextures[readHistoryLenTexIdx].get(), TextureUsageBit::kAllSampled);
 
 		m_historyLengthTexturesImportedOnce = true;
 	}
@@ -123,9 +124,9 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg);
+	cmdb->bindShaderProgram(m_grProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+	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));
@@ -158,7 +159,7 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 	{
 		cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/PackVisibleClusteredObjects.cpp

@@ -34,7 +34,7 @@ Error PackVisibleClusteredObjects::init()
 		variantInit.addMutation("OBJECT_TYPE", U32(type));
 		variantInit.addMutation("THREAD_GROUP_SIZE", m_threadGroupSize);
 		m_packProg->getOrCreateVariant(variantInit, variant);
-		m_grProgs[type] = variant->getProgram();
+		m_grProgs[type].reset(&variant->getProgram());
 	}
 
 	U32 offset = 0;
@@ -110,19 +110,19 @@ void PackVisibleClusteredObjects::dispatchType(WeakArray<TRenderQueueElement> ar
 		}
 	}
 
-	cmdb->bindStorageBuffer(0, 0, GpuSceneBuffer::getSingleton().getBuffer(), rqueue.m_clustererObjectsArrayOffsets[kType],
+	cmdb->bindStorageBuffer(0, 0, &GpuSceneBuffer::getSingleton().getBuffer(), rqueue.m_clustererObjectsArrayOffsets[kType],
 							rqueue.m_clustererObjectsArrayRanges[kType]);
 
-	cmdb->bindStorageBuffer(0, 1, m_allClustererObjects, 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]);
+	cmdb->bindShaderProgram(m_grProgs[kType].get());
 
 	const UVec4 pc(array.getSize());
 	cmdb->setPushConstants(&pc, sizeof(pc));
@@ -138,7 +138,7 @@ void PackVisibleClusteredObjects::populateRenderGraph(RenderingContext& ctx)
 
 	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
 
-	m_allClustererObjectsHandle = rgraph.importBuffer(m_allClustererObjects, BufferUsageBit::kNone);
+	m_allClustererObjectsHandle = rgraph.importBuffer(m_allClustererObjects.get(), BufferUsageBit::kNone);
 	pass.newBufferDependency(m_allClustererObjectsHandle, BufferUsageBit::kStorageComputeWrite);
 
 	pass.setWork([&ctx, this](RenderPassWorkContext& rgraphCtx) {

AnKi/Renderer/PackVisibleClusteredObjects.h

@@ -28,7 +28,7 @@ public:
 
 	void bindClusteredObjectBuffer(CommandBufferPtr& cmdb, U32 set, U32 binding, ClusteredObjectType type) const
 	{
-		cmdb->bindStorageBuffer(set, binding, m_allClustererObjects, m_structureBufferOffsets[type],
+		cmdb->bindStorageBuffer(set, binding, m_allClustererObjects.get(), m_structureBufferOffsets[type],
 								kClusteredObjectSizes[type] * kMaxVisibleClusteredObjects[type]);
 	}
 

AnKi/Renderer/ProbeReflections.cpp

@@ -133,7 +133,7 @@ Error ProbeReflections::initIrradiance()
 
 		const ShaderProgramResourceVariant* variant;
 		m_irradiance.m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_irradiance.m_grProg = variant->getProgram();
+		m_irradiance.m_grProg.reset(&variant->getProgram());
 	}
 
 	// Create buff
@@ -209,7 +209,7 @@ void ProbeReflections::runGBuffer(RenderPassWorkContext& rgraphCtx)
 			args.m_cameraTransform = rqueue.m_cameraTransform;
 			args.m_viewProjectionMatrix = rqueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care about prev mats
-			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeat;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeat.get();
 
 			getRenderer().getSceneDrawer().drawRange(args, rqueue.m_renderables.getBegin() + localStart, rqueue.m_renderables.getBegin() + localEnd,
 													 cmdb);
@@ -270,11 +270,12 @@ void ProbeReflections::runMipmappingOfLightShading(U32 faceIdx, RenderPassWorkCo
 	TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, 0));
 	subresource.m_mipmapCount = m_lightShading.m_mipCount;
 
-	TexturePtr texToBind;
+	Texture* texToBind;
 	rgraphCtx.getRenderTargetState(m_ctx.m_lightShadingRt, subresource, texToBind);
 
 	TextureViewInitInfo viewInit(texToBind, subresource);
-	rgraphCtx.m_commandBuffer->generateMipmaps2d(GrManager::getSingleton().newTextureView(viewInit));
+	TextureViewPtr view = GrManager::getSingleton().newTextureView(viewInit);
+	rgraphCtx.m_commandBuffer->generateMipmaps2d(view.get());
 }
 
 void ProbeReflections::runIrradiance(RenderPassWorkContext& rgraphCtx)
@@ -283,16 +284,16 @@ void ProbeReflections::runIrradiance(RenderPassWorkContext& rgraphCtx)
 
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_irradiance.m_grProg);
+	cmdb->bindShaderProgram(m_irradiance.m_grProg.get());
 
 	// Bind stuff
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	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, 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);
@@ -304,16 +305,16 @@ void ProbeReflections::runIrradianceToRefl(RenderPassWorkContext& rgraphCtx)
 
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_irradianceToRefl.m_grProg);
+	cmdb->bindShaderProgram(m_irradianceToRefl.m_grProg.get());
 
 	// Bind resources
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	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, 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)
 	{
@@ -434,7 +435,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	// Light shading passes
 	{
 		// RT
-		m_ctx.m_lightShadingRt = rgraph.importRenderTarget(TexturePtr(m_ctx.m_probe->m_reflectionTexture), TextureUsageBit::kNone);
+		m_ctx.m_lightShadingRt = rgraph.importRenderTarget(m_ctx.m_probe->m_reflectionTexture, TextureUsageBit::kNone);
 
 		// Passes
 		static constexpr Array<CString, 6> passNames = {"CubeRefl LightShad #0", "CubeRefl LightShad #1", "CubeRefl LightShad #2",
@@ -466,7 +467,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 	// Irradiance passes
 	{
-		m_ctx.m_irradianceDiceValuesBuffHandle = rgraph.importBuffer(m_irradiance.m_diceValuesBuff, BufferUsageBit::kNone);
+		m_ctx.m_irradianceDiceValuesBuffHandle = rgraph.importBuffer(m_irradiance.m_diceValuesBuff.get(), BufferUsageBit::kNone);
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("CubeRefl Irradiance");
 
@@ -563,7 +564,7 @@ void ProbeReflections::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 			args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 			args.m_viewProjectionMatrix = cascadeRenderQueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso.get();
 
 			getRenderer().getSceneDrawer().drawRange(args, cascadeRenderQueue.m_renderables.getBegin() + localStart,
 													 cascadeRenderQueue.m_renderables.getBegin() + localEnd, cmdb);

AnKi/Renderer/ProbeReflections.h

@@ -30,7 +30,7 @@ public:
 		return m_lightShading.m_mipCount;
 	}
 
-	TextureViewPtr getIntegrationLut() const
+	TextureView& getIntegrationLut() const
 	{
 		return m_integrationLut->getTextureView();
 	}

AnKi/Renderer/RenderQueue.h

@@ -267,7 +267,7 @@ class LensFlareQueueElement final
 {
 public:
 	/// Totaly unsafe but we can't have a smart ptr in here since there will be no deletion.
-	const TextureView* m_textureView;
+	TextureView* m_textureView;
 	Vec3 m_worldPosition;
 	Vec2 m_firstFlareSize;
 	Vec4 m_colorMultiplier;
@@ -365,7 +365,7 @@ static_assert(std::is_trivially_destructible<RayTracingInstanceQueueElement>::va
 class SkyboxQueueElement final
 {
 public:
-	const TextureView* m_skyboxTexture;
+	TextureView* m_skyboxTexture;
 	Vec3 m_solidColor;
 
 	class

AnKi/Renderer/Renderer.cpp

@@ -141,13 +141,13 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 		texinit.m_format = Format::kR8G8B8A8_Unorm;
 		TexturePtr tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
 
-		TextureViewInitInfo viewinit(tex);
+		TextureViewInitInfo viewinit(tex.get());
 		m_dummyTexView2d = GrManager::getSingleton().newTextureView(viewinit);
 
 		texinit.m_depth = 4;
 		texinit.m_type = TextureType::k3D;
 		tex = createAndClearRenderTarget(texinit, TextureUsageBit::kAllSampled);
-		viewinit = TextureViewInitInfo(tex);
+		viewinit = TextureViewInitInfo(tex.get());
 		m_dummyTexView3d = GrManager::getSingleton().newTextureView(viewinit);
 
 		m_dummyBuff = GrManager::getSingleton().newBuffer(
@@ -508,7 +508,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 							aspect |= DepthStencilAspectBit::kStencil;
 						}
 
-						TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex, surf, aspect));
+						TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex.get(), surf, aspect));
 
 						fbInit.m_depthStencilAttachment.m_textureView = std::move(view);
 						fbInit.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kClear;
@@ -519,7 +519,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					}
 					else
 					{
-						TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex, surf));
+						TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex.get(), surf));
 
 						fbInit.m_colorAttachmentCount = 1;
 						fbInit.m_colorAttachments[0].m_textureView = view;
@@ -534,7 +534,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					barrier.m_subresource.m_depthStencilAspect = tex->getDepthStencilAspect();
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
-					cmdb->beginRenderPass(fb, colUsage, dsUsage);
+					cmdb->beginRenderPass(fb.get(), colUsage, dsUsage);
 					cmdb->endRenderPass();
 
 					if(!!initialUsage)
@@ -569,12 +569,12 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 					const ShaderProgramResourceVariant* variant;
 					m_clearTexComputeProg->getOrCreateVariant(variantInitInfo, variant);
 
-					cmdb->bindShaderProgram(variant->getProgram());
+					cmdb->bindShaderProgram(&variant->getProgram());
 
 					cmdb->setPushConstants(&clearVal.m_colorf[0], sizeof(clearVal.m_colorf));
 
-					TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex, surf));
-					cmdb->bindImage(0, 0, view);
+					TextureViewPtr view = GrManager::getSingleton().newTextureView(TextureViewInitInfo(tex.get(), surf));
+					cmdb->bindImage(0, 0, view.get());
 
 					const TextureBarrierInfo barrier = {tex.get(), TextureUsageBit::kNone, TextureUsageBit::kImageComputeWrite, surf};
 					cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
@@ -685,7 +685,7 @@ void Renderer::gpuSceneCopy(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
 	m_runCtx.m_gpuSceneHandle =
-		rgraph.importBuffer(GpuSceneBuffer::getSingleton().getBuffer(), GpuSceneBuffer::getSingleton().getBuffer()->getBufferUsage());
+		rgraph.importBuffer(&GpuSceneBuffer::getSingleton().getBuffer(), GpuSceneBuffer::getSingleton().getBuffer().getBufferUsage());
 
 	if(GpuSceneMicroPatcher::getSingleton().patchingIsNeeded())
 	{

AnKi/Renderer/Renderer.h

@@ -103,19 +103,19 @@ public:
 		return m_resourcesDirty;
 	}
 
-	TextureViewPtr getDummyTextureView2d() const
+	TextureView& getDummyTextureView2d() const
 	{
-		return m_dummyTexView2d;
+		return *m_dummyTexView2d;
 	}
 
-	TextureViewPtr getDummyTextureView3d() const
+	TextureView& getDummyTextureView3d() const
 	{
-		return m_dummyTexView3d;
+		return *m_dummyTexView3d;
 	}
 
-	BufferPtr getDummyBuffer() const
+	Buffer& getDummyBuffer() const
 	{
-		return m_dummyBuff;
+		return *m_dummyBuff;
 	}
 
 	const RendererPrecreatedSamplers& getSamplers() const

AnKi/Renderer/RendererObject.cpp

@@ -25,11 +25,11 @@ void RendererObject::bindUniforms(CommandBufferPtr& cmdb, U32 set, U32 binding,
 {
 	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());
 	}
 }
 
@@ -37,11 +37,11 @@ void RendererObject::bindStorage(CommandBufferPtr& cmdb, U32 set, U32 binding, c
 {
 	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());
 	}
 }
 
@@ -71,7 +71,7 @@ Error RendererObject::loadShaderProgram(CString filename, ShaderProgramResourceP
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource(filename, rsrc));
 	const ShaderProgramResourceVariant* variant;
 	rsrc->getOrCreateVariant(variant);
-	grProg = variant->getProgram();
+	grProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }

AnKi/Renderer/RendererObject.h

@@ -45,7 +45,7 @@ protected:
 	/// Used in fullscreen quad draws.
 	static void drawQuad(CommandBufferPtr& cmdb)
 	{
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3, 1);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3, 1);
 	}
 
 	/// Dispatch a compute job equivelent to drawQuad

AnKi/Renderer/RtShadows.cpp

@@ -51,7 +51,7 @@ Error RtShadows::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_rayGenProg->getOrCreateVariant(variantInitInfo, variant);
-		m_rtLibraryGrProg = variant->getProgram();
+		m_rtLibraryGrProg.reset(&variant->getProgram());
 		m_rayGenShaderGroupIdx = variant->getShaderGroupHandleIndex();
 	}
 
@@ -76,11 +76,11 @@ Error RtShadows::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_denoiseProg->getOrCreateVariant(variantInitInfo, variant);
-		m_grDenoiseHorizontalProg = variant->getProgram();
+		m_grDenoiseHorizontalProg.reset(&variant->getProgram());
 
 		variantInitInfo.addMutation("BLUR_ORIENTATION", 1);
 		m_denoiseProg->getOrCreateVariant(variantInitInfo, variant);
-		m_grDenoiseVerticalProg = variant->getProgram();
+		m_grDenoiseVerticalProg.reset(&variant->getProgram());
 	}
 
 	// SVGF variance program
@@ -93,7 +93,7 @@ Error RtShadows::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_svgfVarianceProg->getOrCreateVariant(variantInitInfo, variant);
-		m_svgfVarianceGrProg = variant->getProgram();
+		m_svgfVarianceGrProg.reset(&variant->getProgram());
 	}
 
 	// SVGF atrous program
@@ -107,11 +107,11 @@ Error RtShadows::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_svgfAtrousProg->getOrCreateVariant(variantInitInfo, variant);
-		m_svgfAtrousGrProg = variant->getProgram();
+		m_svgfAtrousGrProg.reset(&variant->getProgram());
 
 		variantInitInfo.addMutation("LAST_PASS", 1);
 		m_svgfAtrousProg->getOrCreateVariant(variantInitInfo, variant);
-		m_svgfAtrousLastPassGrProg = variant->getProgram();
+		m_svgfAtrousLastPassGrProg.reset(&variant->getProgram());
 	}
 
 	// Upscale program
@@ -122,7 +122,7 @@ Error RtShadows::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_upscaleProg->getOrCreateVariant(variantInitInfo, variant);
-		m_upscaleGrProg = variant->getProgram();
+		m_upscaleGrProg.reset(&variant->getProgram());
 	}
 
 	// Debug program
@@ -189,16 +189,16 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	{
 		if(!m_rtsImportedOnce) [[unlikely]]
 		{
-			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt, TextureUsageBit::kSampledFragment);
+			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt.get(), TextureUsageBit::kSampledFragment);
 
-			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx], TextureUsageBit::kSampledFragment);
+			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx].get(), TextureUsageBit::kSampledFragment);
 
 			m_rtsImportedOnce = true;
 		}
 		else
 		{
-			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt);
-			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx]);
+			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt.get());
+			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx].get());
 		}
 
 		if((getPassCountWithoutUpscaling() % 2) == 1)
@@ -213,7 +213,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			m_runCtx.m_intermediateShadowsRts[1] = m_runCtx.m_historyRt;
 		}
 
-		m_runCtx.m_currentMomentsRt = rgraph.importRenderTarget(m_momentsRts[!prevRtIdx], TextureUsageBit::kNone);
+		m_runCtx.m_currentMomentsRt = rgraph.importRenderTarget(m_momentsRts[!prevRtIdx].get(), TextureUsageBit::kNone);
 
 		if(m_useSvgf)
 		{
@@ -422,7 +422,7 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_rtLibraryGrProg);
+	cmdb->bindShaderProgram(m_rtLibraryGrProg.get());
 
 	// Allocate, set and bind global uniforms
 	{
@@ -433,17 +433,17 @@ 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);
+								&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);
-	cmdb->bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
+	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);
+									&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);
+	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);
-	cmdb->bindSampler(kSet, 9, getRenderer().getSamplers().m_nearestNearestClamp);
+	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,7 +470,7 @@ 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)
@@ -479,7 +479,7 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 	}
 	cmdb->setPushConstants(&unis, sizeof(unis));
 
-	cmdb->traceRays(m_runCtx.m_sbtBuffer, m_runCtx.m_sbtOffset, m_sbtRecordSize, m_runCtx.m_hitGroupCount, 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);
 }
 
@@ -487,10 +487,10 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram((m_runCtx.m_denoiseOrientation == 0) ? m_grDenoiseHorizontalProg : m_grDenoiseVerticalProg);
+	cmdb->bindShaderProgram((m_runCtx.m_denoiseOrientation == 0) ? m_grDenoiseHorizontalProg.get() : m_grDenoiseVerticalProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+	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));
@@ -513,10 +513,10 @@ void RtShadows::runSvgfVariance(const RenderingContext& ctx, RenderPassWorkConte
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_svgfVarianceGrProg);
+	cmdb->bindShaderProgram(m_svgfVarianceGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+	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);
@@ -541,15 +541,15 @@ void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext
 
 	if(lastPass)
 	{
-		cmdb->bindShaderProgram(m_svgfAtrousLastPassGrProg);
+		cmdb->bindShaderProgram(m_svgfAtrousLastPassGrProg.get());
 	}
 	else
 	{
-		cmdb->bindShaderProgram(m_svgfAtrousGrProg);
+		cmdb->bindShaderProgram(m_svgfAtrousGrProg.get());
 	}
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+	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]);
@@ -577,10 +577,10 @@ void RtShadows::runUpscale(RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_upscaleGrProg);
+	cmdb->bindShaderProgram(m_upscaleGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+	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);
@@ -608,7 +608,7 @@ void RtShadows::buildSbt(RenderingContext& ctx)
 	RebarAllocation token;
 	U8* sbt = allocateStorage<U8*>(PtrSize(m_sbtRecordSize) * (instanceCount + extraSbtRecords), token);
 	[[maybe_unused]] const U8* sbtStart = sbt;
-	m_runCtx.m_sbtBuffer = RebarTransientMemoryPool::getSingleton().getBuffer();
+	m_runCtx.m_sbtBuffer.reset(const_cast<Buffer*>(&RebarTransientMemoryPool::getSingleton().getBuffer()));
 	m_runCtx.m_sbtOffset = token.m_offset;
 
 	// Set the miss and ray gen handles
@@ -712,7 +712,7 @@ void RtShadows::getDebugRenderTarget(CString rtName, Array<RenderTargetHandle, k
 
 	const ShaderProgramResourceVariant* variant;
 	m_visualizeRenderTargetsProg->getOrCreateVariant(variantInit, variant);
-	optionalShaderProgram = variant->getProgram();
+	optionalShaderProgram.reset(&variant->getProgram());
 }
 
 } // end namespace anki

AnKi/Renderer/Scale.cpp

@@ -83,7 +83,7 @@ Error Scale::init()
 
 		const ShaderProgramResourceVariant* variant;
 		m_scaleProg->getOrCreateVariant(variant);
-		m_scaleGrProg = variant->getProgram();
+		m_scaleGrProg.reset(&variant->getProgram());
 	}
 	else if(m_upscalingMethod == UpscalingMethod::kFsr)
 	{
@@ -96,7 +96,7 @@ Error Scale::init()
 		variantInitInfo.addMutation("FSR_QUALITY", fsrQuality - 1);
 		const ShaderProgramResourceVariant* variant;
 		m_scaleProg->getOrCreateVariant(variantInitInfo, variant);
-		m_scaleGrProg = variant->getProgram();
+		m_scaleGrProg.reset(&variant->getProgram());
 	}
 	else if(m_upscalingMethod == UpscalingMethod::kGr)
 	{
@@ -119,7 +119,7 @@ Error Scale::init()
 		variantInitInfo.addMutation("FSR_QUALITY", 0);
 		const ShaderProgramResourceVariant* variant;
 		m_sharpenProg->getOrCreateVariant(variantInitInfo, variant);
-		m_sharpenGrProg = variant->getProgram();
+		m_sharpenGrProg.reset(&variant->getProgram());
 	}
 
 	// Tonemapping programs
@@ -129,7 +129,7 @@ Error Scale::init()
 			(preferCompute) ? "ShaderBinaries/TonemapCompute.ankiprogbin" : "ShaderBinaries/TonemapRaster.ankiprogbin", m_tonemapProg));
 		const ShaderProgramResourceVariant* variant;
 		m_tonemapProg->getOrCreateVariant(variant);
-		m_tonemapGrProg = variant->getProgram();
+		m_tonemapGrProg.reset(&variant->getProgram());
 	}
 
 	// Descriptors
@@ -316,9 +316,9 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 	const RenderTargetHandle inRt = getRenderer().getTemporalAA().getTonemappedRt();
 	const RenderTargetHandle outRt = m_runCtx.m_upscaledTonemappedRt;
 
-	cmdb->bindShaderProgram(m_scaleGrProg);
+	cmdb->bindShaderProgram(m_scaleGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	if(preferCompute)
@@ -369,7 +369,7 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
@@ -380,9 +380,9 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 	const RenderTargetHandle inRt = m_runCtx.m_tonemappedRt;
 	const RenderTargetHandle outRt = m_runCtx.m_sharpenedRt;
 
-	cmdb->bindShaderProgram(m_sharpenGrProg);
+	cmdb->bindShaderProgram(m_sharpenGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	if(preferCompute)
@@ -417,7 +417,7 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
@@ -437,7 +437,8 @@ 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, srcView, dstView, motionVectorsView, depthView, exposureView, 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)
@@ -447,9 +448,9 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 	const RenderTargetHandle inRt = m_runCtx.m_upscaledHdrRt;
 	const RenderTargetHandle outRt = m_runCtx.m_tonemappedRt;
 
-	cmdb->bindShaderProgram(m_tonemapGrProg);
+	cmdb->bindShaderProgram(m_tonemapGrProg.get());
 
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp.get());
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
@@ -472,7 +473,7 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/ShadowMapping.cpp

@@ -72,7 +72,7 @@ Error ShadowMapping::initInternal()
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ShadowmappingClearDepth.ankiprogbin", m_clearDepthProg));
 	const ShaderProgramResourceVariant* variant;
 	m_clearDepthProg->getOrCreateVariant(variant);
-	m_clearDepthGrProg = variant->getProgram();
+	m_clearDepthGrProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -86,11 +86,11 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 	// Import
 	if(m_rtImportedOnce) [[likely]]
 	{
-		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex);
+		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex.get());
 	}
 	else
 	{
-		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex, TextureUsageBit::kSampledFragment);
+		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex.get(), TextureUsageBit::kSampledFragment);
 		m_rtImportedOnce = true;
 	}
 
@@ -582,10 +582,10 @@ void ShadowMapping::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 		// The 1st drawcall will clear the depth buffer
 		if(work.m_firstRenderableElement == 0)
 		{
-			cmdb->bindShaderProgram(m_clearDepthGrProg);
+			cmdb->bindShaderProgram(m_clearDepthGrProg.get());
 			cmdb->setDepthCompareOperation(CompareOperation::kAlways);
 			cmdb->setPolygonOffset(0.0f, 0.0f);
-			cmdb->drawArrays(PrimitiveTopology::kTriangles, 3, 1);
+			cmdb->draw(PrimitiveTopology::kTriangles, 3, 1);
 
 			// Restore state
 			cmdb->setDepthCompareOperation(CompareOperation::kLess);
@@ -597,7 +597,7 @@ void ShadowMapping::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 		args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 		args.m_viewProjectionMatrix = work.m_renderQueue->m_viewProjectionMatrix;
 		args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-		args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso;
+		args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso.get();
 
 		getRenderer().getSceneDrawer().drawRange(
 			args, work.m_renderQueue->m_renderables.getBegin() + work.m_firstRenderableElement,

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -53,7 +53,7 @@ Error ShadowmapsResolve::initInternal()
 	variantInitInfo.addMutation("PCF", ConfigSet::getSingleton().getRShadowMappingPcf());
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("EngineAssets/BlueNoise_Rgba8_64x64.png", m_noiseImage));
 
@@ -102,7 +102,7 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg);
+	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);
-	cmdb->bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClampShadow);
-	cmdb->bindSampler(0, 7, getRenderer().getSamplers().m_trilinearRepeat);
+	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())
 	{
@@ -132,7 +132,7 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 	else
 	{
 		cmdb->setViewport(0, 0, m_rtDescr.m_width, m_rtDescr.m_height);
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	}
 }
 

AnKi/Renderer/TemporalAA.cpp

@@ -48,7 +48,7 @@ Error TemporalAA::initInternal()
 
 		const ShaderProgramResourceVariant* variant;
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_grProg = variant->getProgram();
+		m_grProg.reset(&variant->getProgram());
 	}
 
 	for(U i = 0; i < 2; ++i)
@@ -85,15 +85,15 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	// Import RTs
 	if(m_rtTexturesImportedOnce[historyRtIdx]) [[likely]]
 	{
-		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx]);
+		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get());
 	}
 	else
 	{
-		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx], TextureUsageBit::kSampledFragment);
+		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get(), TextureUsageBit::kSampledFragment);
 		m_rtTexturesImportedOnce[historyRtIdx] = true;
 	}
 
-	m_runCtx.m_renderRt = rgraph.importRenderTarget(m_rtTextures[renderRtIdx], TextureUsageBit::kNone);
+	m_runCtx.m_renderRt = rgraph.importRenderTarget(m_rtTextures[renderRtIdx].get(), TextureUsageBit::kNone);
 	m_runCtx.m_tonemappedRt = rgraph.newRenderTarget(m_tonemappedRtDescr);
 
 	// Create pass
@@ -131,9 +131,9 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg);
+		cmdb->bindShaderProgram(m_grProg.get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+		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());
@@ -150,7 +150,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		{
 			cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
-			cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+			cmdb->draw(PrimitiveTopology::kTriangles, 3);
 		}
 	});
 }

AnKi/Renderer/Tonemapping.cpp

@@ -36,7 +36,7 @@ Error Tonemapping::initInternal()
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	// Create exposure texture.
 	// WARNING: Use it only as IMAGE and nothing else. It will not be tracked by the rendergraph. No tracking means no
@@ -53,7 +53,7 @@ Error Tonemapping::initInternal()
 void Tonemapping::importRenderTargets(RenderingContext& ctx)
 {
 	// Just import it. It will not be used in resource tracking
-	m_runCtx.m_exposureLuminanceHandle = ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1, TextureUsageBit::kAllImage);
+	m_runCtx.m_exposureLuminanceHandle = ctx.m_renderGraphDescr.importRenderTarget(m_exposureAndAvgLuminance1x1.get(), TextureUsageBit::kAllImage);
 }
 
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
@@ -66,7 +66,7 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 	pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg);
+		cmdb->bindShaderProgram(m_grProg.get());
 		rgraphCtx.bindImage(0, 1, m_runCtx.m_exposureLuminanceHandle);
 
 		TextureSubresourceInfo inputTexSubresource;

AnKi/Renderer/TraditionalDeferredShading.cpp

@@ -63,15 +63,15 @@ Error TraditionalDeferredLightShading::init()
 
 			const ShaderProgramResourceVariant* variant;
 			m_lightProg->getOrCreateVariant(variantInitInfo, variant);
-			m_plightGrProg[specular] = variant->getProgram();
+			m_plightGrProg[specular].reset(&variant->getProgram());
 
 			variantInitInfo.addMutation("LIGHT_TYPE", 1);
 			m_lightProg->getOrCreateVariant(variantInitInfo, variant);
-			m_slightGrProg[specular] = variant->getProgram();
+			m_slightGrProg[specular].reset(&variant->getProgram());
 
 			variantInitInfo.addMutation("LIGHT_TYPE", 2);
 			m_lightProg->getOrCreateVariant(variantInitInfo, variant);
-			m_dirLightGrProg[specular] = variant->getProgram();
+			m_dirLightGrProg[specular].reset(&variant->getProgram());
 		}
 	}
 
@@ -97,7 +97,7 @@ Error TraditionalDeferredLightShading::init()
 			variantInitInfo.addMutation("METHOD", i);
 			const ShaderProgramResourceVariant* variant;
 			m_skyboxProg->getOrCreateVariant(variantInitInfo, variant);
-			m_skyboxGrProgs[i] = variant->getProgram();
+			m_skyboxGrProgs[i].reset(&variant->getProgram());
 		}
 	}
 
@@ -136,7 +136,7 @@ void TraditionalDeferredLightShading::createProxyMeshes()
 	cmdbInit.m_flags = CommandBufferFlag::kSmallBatch | CommandBufferFlag::kGeneralWork;
 
 	CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
-	cmdb->copyBufferToBuffer(transferBuffer, 0, m_proxyVolumesBuffer, 0, bufferSize);
+	cmdb->copyBufferToBuffer(transferBuffer.get(), 0, m_proxyVolumesBuffer.get(), 0, bufferSize);
 	cmdb->flush();
 
 	GrManager::getSingleton().finish();
@@ -157,7 +157,7 @@ void TraditionalDeferredLightShading::bindVertexIndexBuffers(ProxyType proxyType
 	{
 		offset = sizeof(kIcosphereVertices);
 	}
-	cmdb->bindVertexBuffer(0, m_proxyVolumesBuffer, offset, sizeof(Vec3));
+	cmdb->bindVertexBuffer(0, m_proxyVolumesBuffer.get(), offset, sizeof(Vec3));
 
 	// Idx buff
 	if(proxyType == ProxyType::kProxySphere)
@@ -171,7 +171,7 @@ void TraditionalDeferredLightShading::bindVertexIndexBuffers(ProxyType proxyType
 		indexCount = sizeof(kConeIndices) / sizeof(U16);
 	}
 
-	cmdb->bindIndexBuffer(m_proxyVolumesBuffer, offset, IndexType::kU16);
+	cmdb->bindIndexBuffer(m_proxyVolumesBuffer.get(), offset, IndexType::kU16);
 }
 
 void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShadingDrawInfo& info)
@@ -186,15 +186,15 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 	{
 		const Bool isSolidColor = info.m_skybox->m_skyboxTexture == nullptr;
 
-		cmdb->bindShaderProgram(m_skyboxGrProgs[!isSolidColor]);
+		cmdb->bindShaderProgram(m_skyboxGrProgs[!isSolidColor].get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+		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);
-			cmdb->bindTexture(0, 3, TextureViewPtr(const_cast<TextureView*>(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;
@@ -213,7 +213,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		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);
+		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);
+		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]);
+		cmdb->bindShaderProgram(m_dirLightGrProg[info.m_computeSpecular].get());
 
 		DeferredDirectionalLightUniforms* unis =
 			allocateAndBindUniforms<DeferredDirectionalLightUniforms*>(sizeof(DeferredDirectionalLightUniforms), cmdb, 0, 1);
@@ -279,7 +279,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 	// Do point lights
 	U32 indexCount;
 	bindVertexIndexBuffers(ProxyType::kProxySphere, cmdb, indexCount);
-	cmdb->bindShaderProgram(m_plightGrProg[info.m_computeSpecular]);
+	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->drawElements(PrimitiveTopology::kTriangles, indexCount);
+		cmdb->drawIndexed(PrimitiveTopology::kTriangles, indexCount);
 	}
 
 	// Do spot lights
 	bindVertexIndexBuffers(ProxyType::kProxyCone, cmdb, indexCount);
-	cmdb->bindShaderProgram(m_slightGrProg[info.m_computeSpecular]);
+	cmdb->bindShaderProgram(m_slightGrProg[info.m_computeSpecular].get());
 
 	for(const SpotLightQueueElement& splightEl : info.m_spotLights)
 	{
@@ -348,7 +348,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		light->m_innerCos = cos(splightEl.m_innerAngle / 2.0f);
 
 		// Draw
-		cmdb->drawElements(PrimitiveTopology::kTriangles, indexCount);
+		cmdb->drawIndexed(PrimitiveTopology::kTriangles, indexCount);
 	}
 
 	// Restore state

AnKi/Renderer/VolumetricFog.cpp

@@ -33,7 +33,7 @@ Error VolumetricFog::init()
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 	m_workgroupSize[0] = variant->getWorkgroupSizes()[0];
 	m_workgroupSize[1] = variant->getWorkgroupSizes()[1];
 
@@ -60,9 +60,9 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) -> void {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-		cmdb->bindShaderProgram(m_grProg);
+		cmdb->bindShaderProgram(m_grProg.get());
 
-		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+		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());

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -43,7 +43,7 @@ Error VolumetricLightingAccumulation::init()
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 	m_workgroupSize = variant->getWorkgroupSizes();
 
 	// Create RTs
@@ -65,8 +65,8 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 	const U readRtIdx = getRenderer().getFrameCount() & 1;
 
-	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx], TextureUsageBit::kSampledFragment);
-	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx], TextureUsageBit::kNone);
+	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx].get(), TextureUsageBit::kSampledFragment);
+	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx].get(), TextureUsageBit::kNone);
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol light");
 
@@ -90,16 +90,16 @@ void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPass
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->bindShaderProgram(m_grProg);
+	cmdb->bindShaderProgram(m_grProg.get());
 
 	// Bind all
-	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeat);
-	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
-	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClampShadow);
+	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]);
 

AnKi/Renderer/VrsSriGeneration.cpp

@@ -68,15 +68,15 @@ Error VrsSriGeneration::initInternal()
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInit, variant);
-	m_grProg = variant->getProgram();
+	m_grProg.reset(&variant->getProgram());
 
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/VrsSriVisualizeRenderTarget.ankiprogbin", m_visualizeProg));
 	m_visualizeProg->getOrCreateVariant(variant);
-	m_visualizeGrProg = variant->getProgram();
+	m_visualizeGrProg.reset(&variant->getProgram());
 
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/VrsSriDownscale.ankiprogbin", m_downscaleProg));
 	m_downscaleProg->getOrCreateVariant(variant);
-	m_downscaleGrProg = variant->getProgram();
+	m_downscaleGrProg.reset(&variant->getProgram());
 
 	return Error::kNone;
 }
@@ -107,13 +107,13 @@ void VrsSriGeneration::importRenderTargets(RenderingContext& ctx)
 
 	if(m_sriTexImportedOnce)
 	{
-		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex);
-		m_runCtx.m_downscaledRt = ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex);
+		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex.get());
+		m_runCtx.m_downscaledRt = ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex.get());
 	}
 	else
 	{
-		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex, TextureUsageBit::kFramebufferShadingRate);
-		m_runCtx.m_downscaledRt = ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex, TextureUsageBit::kFramebufferShadingRate);
+		m_runCtx.m_rt = ctx.m_renderGraphDescr.importRenderTarget(m_sriTex.get(), TextureUsageBit::kFramebufferShadingRate);
+		m_runCtx.m_downscaledRt = ctx.m_renderGraphDescr.importRenderTarget(m_downscaledSriTex.get(), TextureUsageBit::kFramebufferShadingRate);
 		m_sriTexImportedOnce = true;
 	}
 }
@@ -138,10 +138,10 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_grProg);
+			cmdb->bindShaderProgram(m_grProg.get());
 
 			rgraphCtx.bindColorTexture(0, 0, getRenderer().getLightShading().getRt());
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
+			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));
@@ -164,10 +164,10 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-			cmdb->bindShaderProgram(m_downscaleGrProg);
+			cmdb->bindShaderProgram(m_downscaleGrProg.get());
 
 			rgraphCtx.bindColorTexture(0, 0, m_runCtx.m_rt);
-			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
+			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));

AnKi/Resource/ImageAtlasResource.h

@@ -41,12 +41,12 @@ public:
 	/// Load the atlas.
 	Error load(const ResourceFilename& filename, Bool async);
 
-	TexturePtr getTexture() const
+	const Texture& getTexture() const
 	{
 		return m_image->getTexture();
 	}
 
-	TextureViewPtr getTextureView() const
+	const TextureView& getTextureView() const
 	{
 		return m_image->getTextureView();
 	}

AnKi/Resource/ImageResource.cpp

@@ -233,7 +233,7 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 	m_layerCount = init.m_layerCount;
 
 	// Create the texture view
-	TextureViewInitInfo viewInit(m_tex, "Rsrc");
+	TextureViewInitInfo viewInit(m_tex.get(), "Rsrc");
 	m_texView = GrManager::getSingleton().newTextureView(viewInit);
 
 	return Error::kNone;
@@ -324,9 +324,9 @@ Error ImageResource::load(LoadingContext& ctx)
 				subresource = TextureSubresourceInfo(TextureSurfaceInfo(mip, 0, face, layer));
 			}
 
-			TextureViewPtr tmpView = GrManager::getSingleton().newTextureView(TextureViewInitInfo(ctx.m_tex, subresource, "RsrcTmp"));
+			TextureViewPtr tmpView = GrManager::getSingleton().newTextureView(TextureViewInitInfo(ctx.m_tex.get(), subresource, "RsrcTmp"));
 
-			cmdb->copyBufferToTextureView(handle.getBuffer(), handle.getOffset(), handle.getRange(), tmpView);
+			cmdb->copyBufferToTextureView(&handle.getBuffer(), handle.getOffset(), handle.getRange(), tmpView.get());
 		}
 
 		// Set the barriers of the batch

AnKi/Resource/ImageResource.h

@@ -13,10 +13,8 @@ namespace anki {
 /// @addtogroup resource
 /// @{
 
-/// Image resource class.
-///
-/// It loads or creates an image and then loads it in the GPU. It supports compressed and uncompressed TGAs, PNGs, JPEG
-/// and AnKi's image format.
+/// Image resource class. It loads or creates an image and then loads it in the GPU. It supports compressed and uncompressed TGAs, PNGs, JPEG and
+/// AnKi's image format.
 class ImageResource : public ResourceObject
 {
 public:
@@ -28,15 +26,15 @@ public:
 	Error load(const ResourceFilename& filename, Bool async);
 
 	/// Get the texture.
-	const TexturePtr& getTexture() const
+	Texture& getTexture() const
 	{
-		return m_tex;
+		return *m_tex;
 	}
 
 	/// Get the texture view.
-	const TextureViewPtr& getTextureView() const
+	TextureView& getTextureView() const
 	{
-		return m_texView;
+		return *m_texView;
 	}
 
 	U32 getWidth() const

AnKi/Resource/MaterialResource.cpp

@@ -620,7 +620,7 @@ Error MaterialResource::parseInput(XmlElement inputEl, Bool async, BitSet<128>&
 		ANKI_CHECK(inputEl.getAttributeText("value", texfname));
 		ANKI_CHECK(ResourceManager::getSingleton().loadResource(texfname, foundVar->m_image, async));
 
-		m_textures.emplaceBack(foundVar->m_image->getTexture());
+		m_textures.emplaceBack(&foundVar->m_image->getTexture());
 	}
 	else if(foundVar->m_dataType == ShaderVariableDataType::kU32)
 	{
@@ -645,7 +645,7 @@ Error MaterialResource::parseInput(XmlElement inputEl, Bool async, BitSet<128>&
 		{
 			ANKI_CHECK(ResourceManager::getSingleton().loadResource(value, foundVar->m_image, async));
 
-			foundVar->m_U32 = foundVar->m_image->getTextureView()->getOrCreateBindlessTextureIndex();
+			foundVar->m_U32 = foundVar->m_image->getTextureView().getOrCreateBindlessTextureIndex();
 		}
 		else
 		{
@@ -773,7 +773,7 @@ const MaterialVariant& MaterialResource::getOrCreateVariant(const RenderingKey&
 		ANKI_RESOURCE_LOGF("Fetched skipped mutation on program %s", getFilename().cstr());
 	}
 
-	variant.m_prog = progVariant->getProgram();
+	variant.m_prog.reset(&progVariant->getProgram());
 
 	if(!!(RenderingTechniqueBit(1 << key.getRenderingTechnique()) & RenderingTechniqueBit::kAllRt))
 	{

AnKi/Resource/MeshResource.cpp

@@ -152,11 +152,11 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 			AccelerationStructureInitInfo inf(ResourceString().sprintf("%s_%s", "Blas", basename.cstr()));
 			inf.m_type = AccelerationStructureType::kBottomLevel;
 
-			inf.m_bottomLevel.m_indexBuffer = UnifiedGeometryBuffer::getSingleton().getBuffer();
+			inf.m_bottomLevel.m_indexBuffer = &UnifiedGeometryBuffer::getSingleton().getBuffer();
 			inf.m_bottomLevel.m_indexBufferOffset = lod.m_indexBufferAllocationToken.getOffset();
 			inf.m_bottomLevel.m_indexCount = lod.m_indexCount;
 			inf.m_bottomLevel.m_indexType = m_indexType;
-			inf.m_bottomLevel.m_positionBuffer = UnifiedGeometryBuffer::getSingleton().getBuffer();
+			inf.m_bottomLevel.m_positionBuffer = &UnifiedGeometryBuffer::getSingleton().getBuffer();
 			inf.m_bottomLevel.m_positionBufferOffset = lod.m_vertexBuffersAllocationToken[VertexStreamId::kPosition].getOffset()
 													   + lod.m_fixedUnifiedGeometryBufferOffset[VertexStreamId::kPosition];
 			inf.m_bottomLevel.m_positionStride = getFormatInfo(kMeshRelatedVertexStreamFormats[VertexStreamId::kPosition]).m_texelSize;
@@ -176,20 +176,20 @@ Error MeshResource::load(const ResourceFilename& filename, Bool async)
 
 		for(const Lod& lod : m_lods)
 		{
-			cmdb->fillBuffer(UnifiedGeometryBuffer::getSingleton().getBuffer(), lod.m_indexBufferAllocationToken.getOffset(),
+			cmdb->fillBuffer(&UnifiedGeometryBuffer::getSingleton().getBuffer(), lod.m_indexBufferAllocationToken.getOffset(),
 							 PtrSize(lod.m_indexCount) * getIndexSize(m_indexType), 0);
 
 			for(VertexStreamId stream : EnumIterable(VertexStreamId::kMeshRelatedFirst, VertexStreamId::kMeshRelatedCount))
 			{
 				if(header.m_vertexAttributes[stream].m_format != Format::kNone)
 				{
-					cmdb->fillBuffer(UnifiedGeometryBuffer::getSingleton().getBuffer(), lod.m_vertexBuffersAllocationToken[stream].getOffset(),
+					cmdb->fillBuffer(&UnifiedGeometryBuffer::getSingleton().getBuffer(), lod.m_vertexBuffersAllocationToken[stream].getOffset(),
 									 lod.m_vertexBuffersAllocationToken[stream].getAllocatedSize(), 0);
 				}
 			}
 		}
 
-		const BufferBarrierInfo barrier = {UnifiedGeometryBuffer::getSingleton().getBuffer().get(), BufferUsageBit::kTransferDestination,
+		const BufferBarrierInfo barrier = {&UnifiedGeometryBuffer::getSingleton().getBuffer(), BufferUsageBit::kTransferDestination,
 										   BufferUsageBit::kVertex, 0, kMaxPtrSize};
 
 		cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
@@ -220,7 +220,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	Array<TransferGpuAllocatorHandle, kMaxLodCount*(U32(VertexStreamId::kMeshRelatedCount) + 1)> handles;
 	U32 handleCount = 0;
 
-	BufferPtr unifiedGeometryBuffer = UnifiedGeometryBuffer::getSingleton().getBuffer();
+	Buffer* unifiedGeometryBuffer = &UnifiedGeometryBuffer::getSingleton().getBuffer();
 	const BufferUsageBit unifiedGeometryBufferNonTransferUsage = unifiedGeometryBuffer->getBufferUsage() ^ BufferUsageBit::kTransferDestination;
 
 	CommandBufferInitInfo cmdbinit;
@@ -228,7 +228,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	CommandBufferPtr cmdb = gr.newCommandBuffer(cmdbinit);
 
 	// Set transfer to transfer barrier because of the clear that happened while sync loading
-	const BufferBarrierInfo barrier = {unifiedGeometryBuffer.get(), unifiedGeometryBufferNonTransferUsage, BufferUsageBit::kTransferDestination, 0,
+	const BufferBarrierInfo barrier = {unifiedGeometryBuffer, unifiedGeometryBufferNonTransferUsage, BufferUsageBit::kTransferDestination, 0,
 									   kMaxPtrSize};
 	cmdb->setPipelineBarrier({}, {&barrier, 1}, {});
 
@@ -248,7 +248,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 
 			ANKI_CHECK(loader.storeIndexBuffer(lodIdx, data, indexBufferSize));
 
-			cmdb->copyBufferToBuffer(handle.getBuffer(), handle.getOffset(), unifiedGeometryBuffer, lod.m_indexBufferAllocationToken.getOffset(),
+			cmdb->copyBufferToBuffer(&handle.getBuffer(), handle.getOffset(), unifiedGeometryBuffer, lod.m_indexBufferAllocationToken.getOffset(),
 									 handle.getRange());
 		}
 
@@ -271,7 +271,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 			ANKI_CHECK(loader.storeVertexBuffer(lodIdx, U32(stream), data, vertexBufferSize));
 
 			// Copy
-			cmdb->copyBufferToBuffer(handle.getBuffer(), handle.getOffset(), unifiedGeometryBuffer,
+			cmdb->copyBufferToBuffer(&handle.getBuffer(), handle.getOffset(), unifiedGeometryBuffer,
 									 lod.m_vertexBuffersAllocationToken[stream].getOffset() + lod.m_fixedUnifiedGeometryBufferOffset[stream],
 									 handle.getRange());
 		}
@@ -283,7 +283,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 
 		// Set the barriers
 		BufferBarrierInfo bufferBarrier;
-		bufferBarrier.m_buffer = unifiedGeometryBuffer.get();
+		bufferBarrier.m_buffer = unifiedGeometryBuffer;
 		bufferBarrier.m_offset = 0;
 		bufferBarrier.m_size = kMaxPtrSize;
 		bufferBarrier.m_previousUsage = BufferUsageBit::kTransferDestination;
@@ -302,7 +302,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 		// Build BLASes
 		for(U32 lodIdx = 0; lodIdx < m_lods.getSize(); ++lodIdx)
 		{
-			cmdb->buildAccelerationStructure(m_lods[lodIdx].m_blas);
+			cmdb->buildAccelerationStructure(m_lods[lodIdx].m_blas.get());
 		}
 
 		// Barriers again
@@ -319,7 +319,7 @@ Error MeshResource::loadAsync(MeshBinaryLoader& loader) const
 	{
 		// Only set a barrier
 		BufferBarrierInfo bufferBarrier;
-		bufferBarrier.m_buffer = unifiedGeometryBuffer.get();
+		bufferBarrier.m_buffer = unifiedGeometryBuffer;
 		bufferBarrier.m_offset = 0;
 		bufferBarrier.m_size = kMaxPtrSize;
 		bufferBarrier.m_previousUsage = BufferUsageBit::kTransferDestination;

AnKi/Resource/ShaderProgramResource.cpp

@@ -364,27 +364,24 @@ ShaderProgramResourceVariant* ShaderProgramResource::createNewVariant(const Shad
 		}
 
 		ShaderProgramInitInfo progInf(cprogName);
-		for(ShaderType shaderType : EnumIterable<ShaderType>())
+		Array<ShaderPtr, U32(ShaderType::kCount)> shaderRefs; // Just for refcounting
+		for(ShaderType shaderType : EnumBitsIterable<ShaderType, ShaderTypeBit>(m_shaderStages))
 		{
-			if(!(ShaderTypeBit(1 << shaderType) & m_shaderStages))
-			{
-				continue;
-			}
-
 			ShaderInitInfo inf(cprogName);
 			inf.m_shaderType = shaderType;
 			inf.m_binary = binary.m_codeBlocks[binaryVariant->m_codeBlockIndices[shaderType]].m_binary;
 			inf.m_constValues.setArray((constValueCount) ? constValues.getBegin() : nullptr, constValueCount);
 			ShaderPtr shader = GrManager::getSingleton().newShader(inf);
+			shaderRefs[shaderType] = shader;
 
 			const ShaderTypeBit shaderBit = ShaderTypeBit(1 << shaderType);
 			if(!!(shaderBit & ShaderTypeBit::kAllGraphics))
 			{
-				progInf.m_graphicsShaders[shaderType] = shader;
+				progInf.m_graphicsShaders[shaderType] = shader.get();
 			}
 			else if(shaderType == ShaderType::kCompute)
 			{
-				progInf.m_computeShader = std::move(shader);
+				progInf.m_computeShader = shader.get();
 			}
 			else
 			{

AnKi/Resource/ShaderProgramResource.h

@@ -70,9 +70,9 @@ public:
 	~ShaderProgramResourceVariant();
 
 	/// @note On ray tracing program resources it points to the actual ray tracing program that contains everything.
-	const ShaderProgramPtr& getProgram() const
+	ShaderProgram& getProgram() const
 	{
-		return m_prog;
+		return *m_prog;
 	}
 
 	/// Return true if the the variable is active in this variant.

AnKi/Resource/ShaderProgramResourceSystem.cpp

@@ -48,7 +48,7 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 	ANKI_RESOURCE_LOGI("Creating ray tracing programs");
 	U32 rtProgramCount = 0;
 
-	class Shader
+	class ShaderH
 	{
 	public:
 		ShaderPtr m_shader;
@@ -69,7 +69,7 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 	{
 	public:
 		ResourceString m_name;
-		ResourceDynamicArray<Shader> m_shaders;
+		ResourceDynamicArray<ShaderH> m_shaders;
 		ResourceDynamicArray<ShaderGroup> m_shaderGroups;
 		ShaderTypeBit m_presentStages = ShaderTypeBit::kNone;
 		U32 m_rayTypeCount = 0;
@@ -80,8 +80,8 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 
 		U32 addShader(const ShaderProgramBinaryCodeBlock& codeBlock, CString progName, ShaderType shaderType)
 		{
-			Shader* shader = nullptr;
-			for(Shader& s : m_shaders)
+			ShaderH* shader = nullptr;
+			for(ShaderH& s : m_shaders)
 			{
 				if(s.m_hash == codeBlock.m_hash)
 				{
@@ -375,8 +375,8 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 			outLib.m_rayTypeCount = inLib.m_rayTypeCount;
 
 			ResourceDynamicArray<RayTracingHitGroup> initInfoHitGroups;
-			ResourceDynamicArray<ShaderPtr> missShaders;
-			ResourceDynamicArray<ShaderPtr> rayGenShaders;
+			ResourceDynamicArray<Shader*> missShaders;
+			ResourceDynamicArray<Shader*> rayGenShaders;
 
 			// Add the hitgroups to the init info
 			for(U32 shaderGroupIdx = 0; shaderGroupIdx < inLib.m_shaderGroups.getSize(); ++shaderGroupIdx)
@@ -393,12 +393,12 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 
 					if(inShaderGroup.m_ahit < kMaxU32)
 					{
-						infoHitGroup->m_anyHitShader = inLib.m_shaders[inShaderGroup.m_ahit].m_shader;
+						infoHitGroup->m_anyHitShader = inLib.m_shaders[inShaderGroup.m_ahit].m_shader.get();
 					}
 
 					if(inShaderGroup.m_chit < kMaxU32)
 					{
-						infoHitGroup->m_closestHitShader = inLib.m_shaders[inShaderGroup.m_chit].m_shader;
+						infoHitGroup->m_closestHitShader = inLib.m_shaders[inShaderGroup.m_chit].m_shader.get();
 					}
 
 					// The hit shaders are after ray gen and miss shaders
@@ -411,7 +411,7 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 
 					ANKI_ASSERT(inShaderGroup.m_ahit == kMaxU32 && inShaderGroup.m_chit == kMaxU32 && inShaderGroup.m_rayGen == kMaxU32);
 
-					missShaders.emplaceBack(inLib.m_shaders[inShaderGroup.m_miss].m_shader);
+					missShaders.emplaceBack(inLib.m_shaders[inShaderGroup.m_miss].m_shader.get());
 
 					// The miss shaders are after ray gen
 					const U32 idx = inLib.m_rayGenShaderGroupCount + missShaders.getSize() - 1;
@@ -424,7 +424,7 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceDynamicArray
 					ANKI_ASSERT(inShaderGroup.m_ahit == kMaxU32 && inShaderGroup.m_chit == kMaxU32 && inShaderGroup.m_miss == kMaxU32
 								&& inShaderGroup.m_rayGen < kMaxU32);
 
-					rayGenShaders.emplaceBack(inLib.m_shaders[inShaderGroup.m_rayGen].m_shader);
+					rayGenShaders.emplaceBack(inLib.m_shaders[inShaderGroup.m_rayGen].m_shader.get());
 
 					// Ray gen shaders are first
 					const U32 idx = rayGenShaders.getSize() - 1;

AnKi/Resource/TransferGpuAllocator.h

@@ -48,9 +48,9 @@ public:
 		return *this;
 	}
 
-	const BufferPtr& getBuffer() const
+	Buffer& getBuffer() const
 	{
-		return m_buffer;
+		return *m_buffer;
 	}
 
 	void* getMappedMemory() const

AnKi/Scene/Components/DecalComponent.cpp

@@ -39,7 +39,7 @@ void DecalComponent::setLayer(CString fname, F32 blendFactor, LayerType type)
 	m_dirty = true;
 
 	l.m_image = std::move(rsrc);
-	l.m_bindlessTextureIndex = l.m_image->getTextureView()->getOrCreateBindlessTextureIndex();
+	l.m_bindlessTextureIndex = l.m_image->getTextureView().getOrCreateBindlessTextureIndex();
 	l.m_blendFactor = blendFactor;
 }
 

AnKi/Scene/Components/GlobalIlluminationProbeComponent.cpp

@@ -56,7 +56,7 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 
 		m_volTex = GrManager::getSingleton().newTexture(texInit);
 
-		TextureViewInitInfo viewInit(m_volTex, "GiProbe");
+		TextureViewInitInfo viewInit(m_volTex.get(), "GiProbe");
 		m_volView = GrManager::getSingleton().newTextureView(viewInit);
 
 		m_volTexBindlessIdx = m_volView->getOrCreateBindlessTextureIndex();
@@ -78,8 +78,8 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 		texBarrier.m_texture = m_volTex.get();
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 
-		cmdb->bindShaderProgram(variant->getProgram());
-		cmdb->bindImage(0, 0, m_volView);
+		cmdb->bindShaderProgram(&variant->getProgram());
+		cmdb->bindImage(0, 0, m_volView.get());
 
 		const Vec4 clearColor(0.0f);
 		cmdb->setPushConstants(&clearColor, sizeof(clearColor));

AnKi/Scene/Components/LensFlareComponent.h

@@ -72,7 +72,7 @@ public:
 		el.m_worldPosition = m_worldPosition;
 		el.m_firstFlareSize = m_firstFlareSize;
 		el.m_colorMultiplier = m_colorMul;
-		el.m_textureView = m_image->getTextureView().get();
+		el.m_textureView = &m_image->getTextureView();
 	}
 
 private:

AnKi/Scene/Components/ModelComponent.cpp

@@ -303,11 +303,13 @@ Error ModelComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 		const U32 modelPatchCount = m_model->getModelPatches().getSize();
 		for(U32 i = 0; i < modelPatchCount; ++i)
 		{
-			for(RenderingTechnique t : EnumBitsIterable<RenderingTechnique, RenderingTechniqueBit>(m_patchInfos[i].m_techniques))
+			for(RenderingTechnique t :
+				EnumBitsIterable<RenderingTechnique, RenderingTechniqueBit>(m_patchInfos[i].m_techniques & ~RenderingTechniqueBit::kAllRt))
 			{
-				const GpuSceneRenderableAabb gpuVolume =
-					initGpuSceneRenderableAabb(m_spatial.getAabbWorldSpace().getMin().xyz(), m_spatial.getAabbWorldSpace().getMax().xyz(),
-											   m_patchInfos[i].m_gpuSceneIndexRenderable.get(), m_patchInfos[i].m_renderStateBucketIndices[t].get());
+				const Vec3 aabbMin = m_spatial.getAabbWorldSpace().getMin().xyz();
+				const Vec3 aabbMax = m_spatial.getAabbWorldSpace().getMax().xyz();
+				const GpuSceneRenderableAabb gpuVolume = initGpuSceneRenderableAabb(aabbMin, aabbMax, m_patchInfos[i].m_gpuSceneIndexRenderable.get(),
+																					m_patchInfos[i].m_renderStateBucketIndices[t].get());
 
 				GpuSceneMicroPatcher::getSingleton().newCopy(*info.m_framePool,
 															 m_patchInfos[i].m_gpuSceneIndexRenderableAabbs[t].getOffsetInGpuScene(), gpuVolume);

AnKi/Scene/Components/ReflectionProbeComponent.cpp

@@ -55,7 +55,7 @@ Error ReflectionProbeComponent::update(SceneComponentUpdateInfo& info, Bool& upd
 
 		m_reflectionTex = GrManager::getSingleton().newTexture(texInit);
 
-		TextureViewInitInfo viewInit(m_reflectionTex, "ReflectionPRobe");
+		TextureViewInitInfo viewInit(m_reflectionTex.get(), "ReflectionPRobe");
 		m_reflectionView = GrManager::getSingleton().newTextureView(viewInit);
 
 		m_reflectionTexBindlessIndex = m_reflectionView->getOrCreateBindlessTextureIndex();

AnKi/Scene/Components/SkyboxComponent.cpp

@@ -49,7 +49,7 @@ void SkyboxComponent::setupSkyboxQueueElement(SkyboxQueueElement& queueElement)
 {
 	if(m_type == SkyboxType::kImage2D)
 	{
-		queueElement.m_skyboxTexture = m_image->getTextureView().get();
+		queueElement.m_skyboxTexture = &m_image->getTextureView();
 	}
 	else
 	{

AnKi/Ui/Canvas.cpp

@@ -37,7 +37,7 @@ Error Canvas::init(FontPtr font, U32 fontHeight, U32 width, U32 height)
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 		variantInitInfo.addMutation("TEXTURE_TYPE", i);
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
-		m_grProgs[i] = variant->getProgram();
+		m_grProgs[i].reset(&variant->getProgram());
 	}
 
 	// Sampler
@@ -220,12 +220,12 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 	const F32 fbHeight = drawData.DisplaySize.y * drawData.FramebufferScale.y;
 	cmdb->setViewport(0, 0, U32(fbWidth), U32(fbHeight));
 
-	cmdb->bindVertexBuffer(0, RebarTransientMemoryPool::getSingleton().getBuffer(), vertsToken.m_offset, sizeof(ImDrawVert));
+	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
@@ -285,22 +285,23 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 					// Bind program
 					if(idExtra && idExtra->m_customProgram.isCreated())
 					{
-						cmdb->bindShaderProgram(idExtra->m_customProgram);
+						cmdb->bindShaderProgram(idExtra->m_customProgram.get());
 					}
 					else if(textureView.isCreated())
 					{
-						cmdb->bindShaderProgram(m_grProgs[kRgbaTex]);
+						cmdb->bindShaderProgram(m_grProgs[kRgbaTex].get());
 					}
 					else
 					{
-						cmdb->bindShaderProgram(m_grProgs[kNoTex]);
+						cmdb->bindShaderProgram(m_grProgs[kNoTex].get());
 					}
 
 					// Bindings
 					if(textureView.isCreated())
 					{
-						cmdb->bindSampler(0, 0, (id.m_bits.m_pointSampling) ? m_nearestNearestRepeatSampler : m_linearLinearRepeatSampler);
-						cmdb->bindTexture(0, 1, textureView);
+						cmdb->bindSampler(0, 0,
+										  (id.m_bits.m_pointSampling) ? m_nearestNearestRepeatSampler.get() : m_linearLinearRepeatSampler.get());
+						cmdb->bindTexture(0, 1, textureView.get());
 					}
 
 					// Push constants
@@ -325,7 +326,7 @@ void Canvas::appendToCommandBufferInternal(CommandBufferPtr& cmdb)
 					cmdb->setPushConstants(&pc, sizeof(Vec4) + extraPushConstantsSize);
 
 					// Draw
-					cmdb->drawElements(PrimitiveTopology::kTriangles, pcmd.ElemCount, 1, idxOffset, vertOffset);
+					cmdb->drawIndexed(PrimitiveTopology::kTriangles, pcmd.ElemCount, 1, idxOffset, vertOffset);
 				}
 			}
 			idxOffset += pcmd.ElemCount;

AnKi/Ui/Font.cpp

@@ -79,7 +79,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	m_tex = GrManager::getSingleton().newTexture(texInit);
 
 	// Create the whole texture view
-	m_texView = GrManager::getSingleton().newTextureView(TextureViewInitInfo(m_tex, "Font"));
+	m_texView = GrManager::getSingleton().newTextureView(TextureViewInitInfo(m_tex.get(), "Font"));
 	m_imFontAtlas->SetTexID(UiImageId(m_texView));
 
 	// Do the copy
@@ -88,20 +88,20 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	cmdbInit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
 
-	TextureViewInitInfo viewInit(m_tex, surf, DepthStencilAspectBit::kNone, "TempFont");
+	TextureViewInitInfo viewInit(m_tex.get(), surf, DepthStencilAspectBit::kNone, "TempFont");
 	TextureViewPtr tmpView = GrManager::getSingleton().newTextureView(viewInit);
 
 	TextureBarrierInfo barrier = {m_tex.get(), TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, surf};
 	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
-	cmdb->copyBufferToTextureView(buff, 0, buffSize, tmpView);
+	cmdb->copyBufferToTextureView(buff.get(), 0, buffSize, tmpView.get());
 
 	barrier.m_previousUsage = TextureUsageBit::kTransferDestination;
 	barrier.m_nextUsage = TextureUsageBit::kGenerateMipmaps;
 	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	// Gen mips
-	cmdb->generateMipmaps2d(m_texView);
+	cmdb->generateMipmaps2d(m_texView.get());
 
 	barrier.m_previousUsage = TextureUsageBit::kGenerateMipmaps;
 	barrier.m_nextUsage = TextureUsageBit::kSampledFragment;

AnKi/Util/Ptr.h

@@ -40,6 +40,11 @@ public:
 		return m_ptr;
 	}
 
+	T* tryGet() const
+	{
+		return m_ptr;
+	}
+
 	Bool isCreated() const
 	{
 		return m_ptr != nullptr;

Tests/Gr/Gr.cpp

@@ -269,7 +269,7 @@ static void* setUniforms(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 bind
 {
 	RebarAllocation token;
 	void* ptr = stagingMem->allocateFrame(size, token);
-	cmdb->bindUniformBuffer(set, binding, stagingMem->getBuffer(), token.m_offset, token.m_range);
+	cmdb->bindUniformBuffer(set, binding, &stagingMem->getBuffer(), token.m_offset, token.m_range);
 	return ptr;
 }
 
@@ -277,7 +277,7 @@ static void* setStorage(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 bindi
 {
 	RebarAllocation token;
 	void* ptr = stagingMem->allocateFrame(size, token);
-	cmdb->bindStorageBuffer(set, binding, stagingMem->getBuffer(), token.m_offset, token.m_range);
+	cmdb->bindStorageBuffer(set, binding, &stagingMem->getBuffer(), token.m_offset, token.m_range);
 	return ptr;
 }
 
@@ -290,8 +290,8 @@ static void* setStorage(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 bindi
 		ANKI_TEST_EXPECT_NO_ERR(transfAlloc->allocate(size_, handle_)); \
 		void* f = handle_.getMappedMemory(); \
 		memcpy(f, ptr_, size_); \
-		TextureViewPtr view = g_gr->newTextureView(TextureViewInitInfo(tex_, surf_)); \
-		cmdb_->copyBufferToTextureView(handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view); \
+		TextureViewPtr view = g_gr->newTextureView(TextureViewInitInfo(tex_.get(), surf_)); \
+		cmdb_->copyBufferToTextureView(&handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view.get()); \
 	} while(0)
 
 #define UPLOAD_TEX_VOL(cmdb_, tex_, vol_, ptr_, size_, handle_) \
@@ -300,8 +300,8 @@ static void* setStorage(PtrSize size, CommandBufferPtr& cmdb, U32 set, U32 bindi
 		ANKI_TEST_EXPECT_NO_ERR(transfAlloc->allocate(size_, handle_)); \
 		void* f = handle_.getMappedMemory(); \
 		memcpy(f, ptr_, size_); \
-		TextureViewPtr view = g_gr->newTextureView(TextureViewInitInfo(tex_, vol_)); \
-		cmdb_->copyBufferToTextureView(handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view); \
+		TextureViewPtr view = g_gr->newTextureView(TextureViewInitInfo(tex_.get(), vol_)); \
+		cmdb_->copyBufferToTextureView(&handle_.getBuffer(), handle_.getOffset(), handle_.getRange(), view.get()); \
 	} while(0)
 
 constexpr Format kDsFormat = Format::kD24_Unorm_S8_Uint;
@@ -311,15 +311,15 @@ static ShaderProgramPtr createProgram(CString vertSrc, CString fragSrc, GrManage
 	ShaderPtr vert = createShader(vertSrc, ShaderType::kVertex, gr);
 	ShaderPtr frag = createShader(fragSrc, ShaderType::kFragment, gr);
 	ShaderProgramInitInfo inf;
-	inf.m_graphicsShaders[ShaderType::kVertex] = vert;
-	inf.m_graphicsShaders[ShaderType::kFragment] = frag;
+	inf.m_graphicsShaders[ShaderType::kVertex] = vert.get();
+	inf.m_graphicsShaders[ShaderType::kFragment] = frag.get();
 	return gr.newShaderProgram(inf);
 }
 
 static FramebufferPtr createColorFb(GrManager& gr, TexturePtr tex)
 {
 	TextureViewInitInfo init;
-	init.m_texture = tex;
+	init.m_texture = tex.get();
 	TextureViewPtr view = gr.newTextureView(init);
 
 	FramebufferInitInfo fbinit;
@@ -485,7 +485,7 @@ ANKI_TEST(Gr, ClearScreen)
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb, {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 		cmdb->flush();
@@ -544,10 +544,10 @@ void main()
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb, {{TextureUsageBit::kFramebufferWrite}}, {});
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kFramebufferWrite}}, {});
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 		cmdb->flush();
@@ -617,7 +617,7 @@ ANKI_TEST(Gr, ViewportAndScissor)
 			vp[1] + RENDER_AREA_MARGIN,
 			vp[2] - RENDER_AREA_MARGIN * 2,
 			vp[3] - RENDER_AREA_MARGIN * 2);
-		cmdb->drawArrays(PrimitiveTopology::TRIANGLE_STRIP, 4);
+		cmdb->draw(PrimitiveTopology::TRIANGLE_STRIP, 4);
 		cmdb->endRenderPass();
 		cmdb->flush();
 
@@ -669,13 +669,13 @@ void main()
 	init.m_type = TextureType::k2D;
 	TexturePtr rt = g_gr->newTexture(init);
 
-	TextureViewInitInfo viewInit(rt);
+	TextureViewInitInfo viewInit(rt.get());
 	TextureViewPtr texView = g_gr->newTextureView(viewInit);
 
 	Array<FramebufferPtr, 4> fb;
 	for(FramebufferPtr& f : fb)
 	{
-		TextureViewInitInfo viewInf(rt);
+		TextureViewInitInfo viewInf(rt.get());
 		TextureViewPtr view = g_gr->newTextureView(viewInf);
 
 		FramebufferInitInfo fbinit;
@@ -716,7 +716,7 @@ void main()
 
 			cmdb->setViewport(0, 0, RT_WIDTH, RT_HEIGHT);
 			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
-			cmdb->beginRenderPass(fb[0], {{TextureUsageBit::kFramebufferWrite}}, {});
+			cmdb->beginRenderPass(fb[0].get(), {{TextureUsageBit::kFramebufferWrite}}, {});
 			cmdb->endRenderPass();
 			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
 			cmdb->flush();
@@ -731,21 +731,21 @@ void main()
 		auto vp = VIEWPORTS[(i / 30) % 4];
 		cmdb->setViewport(vp[0], vp[1], vp[2], vp[3]);
 		cmdb->setScissor(vp[0] + SCISSOR_MARGIN, vp[1] + SCISSOR_MARGIN, vp[2] - SCISSOR_MARGIN * 2, vp[3] - SCISSOR_MARGIN * 2);
-		cmdb->bindShaderProgram(prog);
-		cmdb->beginRenderPass(fb[i % 4], {{TextureUsageBit::kFramebufferWrite}}, {}, vp[0] + RENDER_AREA_MARGIN, vp[1] + RENDER_AREA_MARGIN,
+		cmdb->bindShaderProgram(prog.get());
+		cmdb->beginRenderPass(fb[i % 4].get(), {{TextureUsageBit::kFramebufferWrite}}, {}, vp[0] + RENDER_AREA_MARGIN, vp[1] + RENDER_AREA_MARGIN,
 							  vp[2] - RENDER_AREA_MARGIN * 2, vp[3] - RENDER_AREA_MARGIN * 2);
-		cmdb->drawArrays(PrimitiveTopology::kTriangleStrip, 4);
+		cmdb->draw(PrimitiveTopology::kTriangleStrip, 4);
 		cmdb->endRenderPass();
 
 		// Draw onscreen
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->setScissor(0, 0, g_win->getWidth(), g_win->getHeight());
-		cmdb->bindShaderProgram(blitProg);
+		cmdb->bindShaderProgram(blitProg.get());
 		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
-		cmdb->bindTextureAndSampler(0, 0, texView, sampler);
+		cmdb->bindTextureAndSampler(0, 0, texView.get(), sampler.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb, {TextureUsageBit::kFramebufferWrite}, {});
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 6);
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 
@@ -826,11 +826,11 @@ ANKI_TEST(Gr, DrawWithUniforms)
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb, {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
 
-		cmdb->bindUniformBuffer(0, 0, b, 0, kMaxPtrSize);
+		cmdb->bindUniformBuffer(0, 0, b.get(), 0, kMaxPtrSize);
 
 		// Uploaded buffer
 		Vec4* rotMat = SET_UNIFORMS(Vec4*, sizeof(Vec4), cmdb, 0, 1);
@@ -840,7 +840,7 @@ ANKI_TEST(Gr, DrawWithUniforms)
 		(*rotMat)[2] = sin(angle);
 		(*rotMat)[3] = cos(angle);
 
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 		cmdb->flush();
@@ -909,18 +909,18 @@ ANKI_TEST(Gr, DrawWithVertex)
 		cinit.m_flags = CommandBufferFlag::kGeneralWork;
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
-		cmdb->bindVertexBuffer(0, b, 0, sizeof(Vert));
-		cmdb->bindVertexBuffer(1, c, 0, sizeof(Vec3));
+		cmdb->bindVertexBuffer(0, b.get(), 0, sizeof(Vert));
+		cmdb->bindVertexBuffer(1, c.get(), 0, sizeof(Vec3));
 		cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
 		cmdb->setVertexAttribute(1, 0, Format::kR8G8B8_Unorm, sizeof(Vec3));
 		cmdb->setVertexAttribute(2, 1, Format::kR32G32B32_Sfloat, 0);
 
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->setPolygonOffset(0.0, 0.0);
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb, {TextureUsageBit::kFramebufferWrite}, {});
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->draw(PrimitiveTopology::kTriangles, 3);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 		cmdb->flush();
@@ -967,7 +967,7 @@ ANKI_TEST(Gr, Texture)
 
 	TexturePtr b = g_gr->newTexture(init);
 
-	TextureViewInitInfo view(b);
+	TextureViewInitInfo view(b.get());
 	TextureViewPtr v = g_gr->newTextureView(view);
 
 	COMMON_END()
@@ -1003,7 +1003,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 
 	TexturePtr a = g_gr->newTexture(init);
 
-	TextureViewPtr aView = g_gr->newTextureView(TextureViewInitInfo(a));
+	TextureViewPtr aView = g_gr->newTextureView(TextureViewInitInfo(a.get()));
 
 	//
 	// Create texture B
@@ -1015,7 +1015,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 
 	TexturePtr b = g_gr->newTexture(init);
 
-	TextureViewPtr bView = g_gr->newTextureView(TextureViewInitInfo(b));
+	TextureViewPtr bView = g_gr->newTextureView(TextureViewInitInfo(b.get()));
 
 	//
 	// Upload all textures
@@ -1048,7 +1048,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 	// Gen mips
 	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kTransferDestination, TextureUsageBit::kGenerateMipmaps, TextureSurfaceInfo(0, 0, 0, 0));
 
-	cmdb->generateMipmaps2d(g_gr->newTextureView(TextureViewInitInfo(b)));
+	cmdb->generateMipmaps2d(g_gr->newTextureView(TextureViewInitInfo(b.get())).get());
 
 	// Set barriers
 	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
@@ -1130,16 +1130,16 @@ void main()
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(fb, {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
 
 		Vec4 pc(F32(g_win->getWidth()), F32(g_win->getHeight()), 0.0f, 0.0f);
 		cmdb->setPushConstants(&pc, sizeof(pc));
 
-		cmdb->bindTextureAndSampler(0, 0, aView, sampler);
-		cmdb->bindTextureAndSampler(0, 1, bView, sampler);
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 6);
+		cmdb->bindTextureAndSampler(0, 0, aView.get(), sampler.get());
+		cmdb->bindTextureAndSampler(0, 1, bView.get(), sampler.get());
+		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 		cmdb->flush();
@@ -1177,12 +1177,12 @@ static void drawOffscreenDrawcalls([[maybe_unused]] GrManager& gr, ShaderProgram
 	*color++ = Vec4(1.0, 0.0, 0.0, 0.0);
 	*color = Vec4(0.0, 1.0, 0.0, 0.0);
 
-	cmdb->bindVertexBuffer(0, vertBuff, 0, sizeof(Vec3));
+	cmdb->bindVertexBuffer(0, vertBuff.get(), 0, sizeof(Vec3));
 	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
-	cmdb->bindShaderProgram(prog);
-	cmdb->bindIndexBuffer(indexBuff, 0, IndexType::kU16);
+	cmdb->bindShaderProgram(prog.get());
+	cmdb->bindIndexBuffer(indexBuff.get(), 0, IndexType::kU16);
 	cmdb->setViewport(0, 0, viewPortSize, viewPortSize);
-	cmdb->drawElements(PrimitiveTopology::kTriangles, 6 * 2 * 3);
+	cmdb->drawIndexed(PrimitiveTopology::kTriangles, 6 * 2 * 3);
 
 	// 2nd draw
 	modelMat = Mat4(Vec4(0.5, 0.5, 0.0, 1.0), Mat3(Euler(ang * 2.0f, ang, ang / 3.0f * 2.0f)), 1.0f);
@@ -1194,7 +1194,7 @@ static void drawOffscreenDrawcalls([[maybe_unused]] GrManager& gr, ShaderProgram
 	*color++ = Vec4(0.0, 0.0, 1.0, 0.0);
 	*color = Vec4(0.0, 1.0, 1.0, 0.0);
 
-	cmdb->drawElements(PrimitiveTopology::kTriangles, 6 * 2 * 3);
+	cmdb->drawIndexed(PrimitiveTopology::kTriangles, 6 * 2 * 3);
 }
 
 static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
@@ -1220,8 +1220,8 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 	TexturePtr col0 = gr.newTexture(init);
 	TexturePtr col1 = gr.newTexture(init);
 
-	TextureViewPtr col0View = gr.newTextureView(TextureViewInitInfo(col0));
-	TextureViewPtr col1View = gr.newTextureView(TextureViewInitInfo(col1));
+	TextureViewPtr col0View = gr.newTextureView(TextureViewInitInfo(col0.get()));
+	TextureViewPtr col1View = gr.newTextureView(TextureViewInitInfo(col1.get()));
 
 	init.m_format = kDsFormat;
 	TexturePtr dp = gr.newTexture(init);
@@ -1231,11 +1231,11 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 	//
 	FramebufferInitInfo fbinit;
 	fbinit.m_colorAttachmentCount = 2;
-	fbinit.m_colorAttachments[0].m_textureView = gr.newTextureView(TextureViewInitInfo(col0));
+	fbinit.m_colorAttachments[0].m_textureView = gr.newTextureView(TextureViewInitInfo(col0.get()));
 	fbinit.m_colorAttachments[0].m_clearValue.m_colorf = {{0.1f, 0.0f, 0.0f, 0.0f}};
-	fbinit.m_colorAttachments[1].m_textureView = gr.newTextureView(TextureViewInitInfo(col1));
+	fbinit.m_colorAttachments[1].m_textureView = gr.newTextureView(TextureViewInitInfo(col1.get()));
 	fbinit.m_colorAttachments[1].m_clearValue.m_colorf = {{0.0f, 0.1f, 0.0f, 0.0f}};
-	TextureViewInitInfo viewInit(dp);
+	TextureViewInitInfo viewInit(dp.get());
 	viewInit.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 	fbinit.m_depthStencilAttachment.m_textureView = gr.newTextureView(viewInit);
 	fbinit.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0;
@@ -1273,7 +1273,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
 		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
 		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kNone, TextureUsageBit::kAllFramebuffer, TextureSurfaceInfo(0, 0, 0, 0));
-		cmdb->beginRenderPass(fb, {{TextureUsageBit::kFramebufferWrite, TextureUsageBit::kFramebufferWrite}}, TextureUsageBit::kAllFramebuffer);
+		cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kFramebufferWrite, TextureUsageBit::kFramebufferWrite}}, TextureUsageBit::kAllFramebuffer);
 
 		if(!useSecondLevel)
 		{
@@ -1283,7 +1283,7 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 		{
 			CommandBufferInitInfo cinit;
 			cinit.m_flags = CommandBufferFlag::kSecondLevel | CommandBufferFlag::kGeneralWork;
-			cinit.m_framebuffer = fb;
+			cinit.m_framebuffer = fb.get();
 			CommandBufferPtr cmdb2 = gr.newCommandBuffer(cinit);
 
 			drawOffscreenDrawcalls(gr, prog, cmdb2, TEX_SIZE, indices, verts);
@@ -1305,12 +1305,12 @@ static void drawOffscreen(GrManager& gr, Bool useSecondLevel)
 		FramebufferPtr dfb = createColorFb(gr, presentTex);
 
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb, {TextureUsageBit::kFramebufferWrite}, {});
-		cmdb->bindShaderProgram(resolveProg);
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->bindShaderProgram(resolveProg.get());
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
-		cmdb->bindTextureAndSampler(0, 0, col0View, sampler);
-		cmdb->bindTextureAndSampler(0, 2, col1View, sampler);
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 6);
+		cmdb->bindTextureAndSampler(0, 0, col0View.get(), sampler.get());
+		cmdb->bindTextureAndSampler(0, 2, col1View.get(), sampler.get());
+		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 
@@ -1364,7 +1364,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 
 	TexturePtr tex = g_gr->newTexture(init);
 
-	TextureViewInitInfo viewInit(tex);
+	TextureViewInitInfo viewInit(tex.get());
 	viewInit.m_firstMipmap = 1;
 	viewInit.m_mipmapCount = 1;
 	TextureViewPtr view = g_gr->newTextureView(viewInit);
@@ -1375,7 +1375,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 	// Create shader & compute prog
 	ShaderPtr shader = createShader(COMP_WRITE_IMAGE_SRC, ShaderType::kCompute, *g_gr);
 	ShaderProgramInitInfo sprogInit;
-	sprogInit.m_computeShader = shader;
+	sprogInit.m_computeShader = shader.get();
 	ShaderProgramPtr compProg = g_gr->newShaderProgram(sprogInit);
 
 	// Write texture data
@@ -1386,16 +1386,16 @@ ANKI_TEST(Gr, ImageLoadStore)
 
 	ClearValue clear;
 	clear.m_colorf = {{0.0, 1.0, 0.0, 1.0}};
-	TextureViewInitInfo viewInit2(tex, TextureSurfaceInfo(0, 0, 0, 0));
-	cmdb->clearTextureView(g_gr->newTextureView(viewInit2), clear);
+	TextureViewInitInfo viewInit2(tex.get(), TextureSurfaceInfo(0, 0, 0, 0));
+	cmdb->clearTextureView(g_gr->newTextureView(viewInit2).get(), clear);
 
 	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
 
 	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceInfo(1, 0, 0, 0));
 
 	clear.m_colorf = {{0.0, 0.0, 1.0, 1.0}};
-	TextureViewInitInfo viewInit3(tex, TextureSurfaceInfo(1, 0, 0, 0));
-	cmdb->clearTextureView(g_gr->newTextureView(viewInit3), clear);
+	TextureViewInitInfo viewInit3(tex.get(), TextureSurfaceInfo(1, 0, 0, 0));
+	cmdb->clearTextureView(g_gr->newTextureView(viewInit3).get(), clear);
 
 	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kImageComputeWrite, TextureSurfaceInfo(1, 0, 0, 0));
 
@@ -1417,21 +1417,21 @@ ANKI_TEST(Gr, ImageLoadStore)
 		*col = Vec4(F32(iterations) / F32(ITERATION_COUNT));
 
 		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kImageComputeWrite, TextureSurfaceInfo(1, 0, 0, 0));
-		cmdb->bindShaderProgram(compProg);
-		cmdb->bindImage(0, 0, view);
+		cmdb->bindShaderProgram(compProg.get());
+		cmdb->bindImage(0, 0, view.get());
 		cmdb->dispatchCompute(WIDTH / 2, HEIGHT / 2, 1);
 		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kImageComputeWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(1, 0, 0, 0));
 
 		// Present image
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
 
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 		TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 		FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb, {TextureUsageBit::kFramebufferWrite}, {});
-		cmdb->bindTextureAndSampler(0, 0, g_gr->newTextureView(TextureViewInitInfo(tex)), sampler);
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 6);
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->bindTextureAndSampler(0, 0, g_gr->newTextureView(TextureViewInitInfo(tex.get())).get(), sampler.get());
+		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
 
@@ -1531,17 +1531,17 @@ ANKI_TEST(Gr, 3DTextures)
 		TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 		FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 		presentBarrierA(cmdb, presentTex);
-		cmdb->beginRenderPass(dfb, {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
 
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 
 		Vec4* uv = SET_UNIFORMS(Vec4*, sizeof(Vec4), cmdb, 0, 0);
 
 		U32 idx = U32((F32(ITERATION_COUNT - iterations - 1) / F32(ITERATION_COUNT)) * F32(TEX_COORDS_LOD.getSize()));
 		*uv = TEX_COORDS_LOD[idx];
 
-		cmdb->bindTextureAndSampler(0, 1, g_gr->newTextureView(TextureViewInitInfo(a)), sampler);
-		cmdb->drawArrays(PrimitiveTopology::kTriangles, 6);
+		cmdb->bindTextureAndSampler(0, 1, g_gr->newTextureView(TextureViewInitInfo(a.get())).get(), sampler.get());
+		cmdb->draw(PrimitiveTopology::kTriangles, 6);
 
 		cmdb->endRenderPass();
 		presentBarrierB(cmdb, presentTex);
@@ -1596,7 +1596,7 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// SM to exponential SM
-	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex, TextureUsageBit::kSampledFragment);
+	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("ESM");
 		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSampledFragment);
@@ -1615,7 +1615,7 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// GI light
-	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex, TextureUsageBit::kSampledFragment);
+	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
 	{
 		TextureSubresourceInfo subresource(TextureSurfaceInfo(0, 0, faceIdx, 0));
@@ -1715,7 +1715,7 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// Light shading
-	RenderTargetHandle lightRt = descr.importRenderTarget(dummyTex, TextureUsageBit::kNone);
+	RenderTargetHandle lightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kNone);
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Light shading");
 
@@ -1731,8 +1731,8 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// TAA
-	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex, TextureUsageBit::kSampledFragment);
-	RenderTargetHandle taaRt = descr.importRenderTarget(dummyTex, TextureUsageBit::kNone);
+	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
+	RenderTargetHandle taaRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kNone);
 	{
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Temporal AA");
 
@@ -1809,7 +1809,7 @@ void main()
 
 	ShaderPtr comp = createShader(COMP_SRC, ShaderType::kCompute, *g_gr);
 	ShaderProgramInitInfo sinf;
-	sinf.m_computeShader = comp;
+	sinf.m_computeShader = comp.get();
 	ShaderProgramPtr prog = g_gr->newShaderProgram(sinf);
 
 	// Create the texture
@@ -1820,7 +1820,7 @@ void main()
 	texInit.m_usage = TextureUsageBit::kTransferDestination | TextureUsageBit::kAllSampled;
 	texInit.m_mipmapCount = 2;
 	TexturePtr tex = g_gr->newTexture(texInit);
-	TextureViewPtr texView = g_gr->newTextureView(TextureViewInitInfo(tex));
+	TextureViewPtr texView = g_gr->newTextureView(TextureViewInitInfo(tex.get()));
 
 	SamplerInitInfo samplerInit;
 	SamplerPtr sampler = g_gr->newSampler(samplerInit);
@@ -1861,15 +1861,15 @@ void main()
 	TextureSubresourceInfo subresource;
 	subresource.m_mipmapCount = texInit.m_mipmapCount;
 	setTextureBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, subresource);
-	cmdb->copyBufferToTextureView(uploadBuff, 0, uploadBuff->getSize(),
-								  g_gr->newTextureView(TextureViewInitInfo(tex, TextureSurfaceInfo(0, 0, 0, 0))));
-	cmdb->copyBufferToTextureView(uploadBuff2, 0, uploadBuff2->getSize(),
-								  g_gr->newTextureView(TextureViewInitInfo(tex, TextureSurfaceInfo(1, 0, 0, 0))));
+	cmdb->copyBufferToTextureView(uploadBuff.get(), 0, uploadBuff->getSize(),
+								  g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceInfo(0, 0, 0, 0))).get());
+	cmdb->copyBufferToTextureView(uploadBuff2.get(), 0, uploadBuff2->getSize(),
+								  g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceInfo(1, 0, 0, 0))).get());
 
 	setTextureBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute, subresource);
-	cmdb->bindShaderProgram(prog);
-	cmdb->bindTextureAndSampler(0, 0, texView, sampler);
-	cmdb->bindStorageBuffer(0, 1, resultBuff, 0, resultBuff->getSize());
+	cmdb->bindShaderProgram(prog.get());
+	cmdb->bindTextureAndSampler(0, 0, texView.get(), sampler.get());
+	cmdb->bindStorageBuffer(0, 1, resultBuff.get(), 0, resultBuff->getSize());
 	cmdb->dispatchCompute(1, 1, 1);
 
 	setBufferBarrier(cmdb, resultBuff, BufferUsageBit::kStorageComputeWrite, BufferUsageBit::kStorageComputeWrite, 0, resultBuff->getSize());
@@ -1956,8 +1956,8 @@ void main()
 		createShader(FRAG_SRC, ShaderType::kFragment, *g_gr,
 					 Array<ShaderSpecializationConstValue, 2>{{ShaderSpecializationConstValue(-2147483647), ShaderSpecializationConstValue(-1.0f)}});
 	ShaderProgramInitInfo sinf;
-	sinf.m_graphicsShaders[ShaderType::kVertex] = vert;
-	sinf.m_graphicsShaders[ShaderType::kFragment] = frag;
+	sinf.m_graphicsShaders[ShaderType::kVertex] = vert.get();
+	sinf.m_graphicsShaders[ShaderType::kFragment] = frag.get();
 	ShaderProgramPtr prog = g_gr->newShaderProgram(sinf);
 
 	// Create the result buffer
@@ -1970,13 +1970,13 @@ void main()
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 	cmdb->setViewport(0, 0, WIDTH, HEIGHT);
-	cmdb->bindShaderProgram(prog);
-	cmdb->bindStorageBuffer(0, 0, resultBuff, 0, resultBuff->getSize());
+	cmdb->bindShaderProgram(prog.get());
+	cmdb->bindStorageBuffer(0, 0, resultBuff.get(), 0, resultBuff->getSize());
 	TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 	FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 	presentBarrierA(cmdb, presentTex);
-	cmdb->beginRenderPass(dfb, {TextureUsageBit::kFramebufferWrite}, {});
-	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+	cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+	cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	cmdb->endRenderPass();
 	presentBarrierB(cmdb, presentTex);
 	cmdb->flush();
@@ -2081,11 +2081,11 @@ void main()
 	cinit.m_flags = CommandBufferFlag::kGeneralWork;
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
-	cmdb->fillBuffer(resultBuff, 0, resultBuff->getSize(), 0);
+	cmdb->fillBuffer(resultBuff.get(), 0, resultBuff->getSize(), 0);
 	setBufferBarrier(cmdb, resultBuff, BufferUsageBit::kTransferDestination, BufferUsageBit::kStorageFragmentWrite, 0, resultBuff->getSize());
 
 	cmdb->setViewport(0, 0, WIDTH, HEIGHT);
-	cmdb->bindShaderProgram(prog);
+	cmdb->bindShaderProgram(prog.get());
 
 	struct PushConstants
 	{
@@ -2097,12 +2097,12 @@ void main()
 	pc.m_mat(0, 1) = 0.5f;
 	cmdb->setPushConstants(&pc, sizeof(pc));
 
-	cmdb->bindStorageBuffer(0, 0, resultBuff, 0, resultBuff->getSize());
+	cmdb->bindStorageBuffer(0, 0, resultBuff.get(), 0, resultBuff->getSize());
 	TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
 	FramebufferPtr dfb = createColorFb(*g_gr, presentTex);
 	presentBarrierA(cmdb, presentTex);
-	cmdb->beginRenderPass(dfb, {TextureUsageBit::kFramebufferWrite}, {});
-	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
+	cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+	cmdb->draw(PrimitiveTopology::kTriangles, 3);
 	cmdb->endRenderPass();
 	presentBarrierB(cmdb, presentTex);
 	cmdb->flush();
@@ -2161,7 +2161,7 @@ void main()
 
 	ShaderPtr shader = createShader(PROG_SRC, ShaderType::kCompute, *g_gr);
 	ShaderProgramInitInfo sprogInit;
-	sprogInit.m_computeShader = shader;
+	sprogInit.m_computeShader = shader.get();
 	ShaderProgramPtr prog = g_gr->newShaderProgram(sprogInit);
 
 	// Run
@@ -2171,12 +2171,12 @@ void main()
 
 	for(U32 i = 0; i < uniformBuffers.getSize(); ++i)
 	{
-		cmdb->bindUniformBuffer(0, 0, uniformBuffers[i], 0, kMaxPtrSize, i);
+		cmdb->bindUniformBuffer(0, 0, uniformBuffers[i].get(), 0, kMaxPtrSize, i);
 	}
 
-	cmdb->bindStorageBuffer(0, 1, resBuff, 0, kMaxPtrSize);
+	cmdb->bindStorageBuffer(0, 1, resBuff.get(), 0, kMaxPtrSize);
 
-	cmdb->bindShaderProgram(prog);
+	cmdb->bindShaderProgram(prog.get());
 	cmdb->dispatchCompute(1, 1, 1);
 
 	cmdb->flush();
@@ -2353,7 +2353,7 @@ void main()
 
 	ShaderPtr shader = createShader(PROG_SRC, ShaderType::kCompute, *g_gr);
 	ShaderProgramInitInfo sprogInit;
-	sprogInit.m_computeShader = shader;
+	sprogInit.m_computeShader = shader.get();
 	ShaderProgramPtr prog = g_gr->newShaderProgram(sprogInit);
 
 	// Create buffers
@@ -2377,7 +2377,7 @@ void main()
 	cinit.m_flags = CommandBufferFlag::kComputeWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
-	cmdb->bindShaderProgram(prog);
+	cmdb->bindShaderProgram(prog.get());
 
 	struct Address
 	{
@@ -2450,10 +2450,10 @@ ANKI_TEST(Gr, RayQuery)
 	{
 		AccelerationStructureInitInfo init;
 		init.m_type = AccelerationStructureType::kBottomLevel;
-		init.m_bottomLevel.m_indexBuffer = idxBuffer;
+		init.m_bottomLevel.m_indexBuffer = idxBuffer.get();
 		init.m_bottomLevel.m_indexCount = 3;
 		init.m_bottomLevel.m_indexType = IndexType::kU16;
-		init.m_bottomLevel.m_positionBuffer = vertBuffer;
+		init.m_bottomLevel.m_positionBuffer = vertBuffer.get();
 		init.m_bottomLevel.m_positionCount = 3;
 		init.m_bottomLevel.m_positionsFormat = Format::kR32G32B32_Sfloat;
 		init.m_bottomLevel.m_positionStride = 4 * 4;
@@ -2598,11 +2598,11 @@ void main()
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		setAccelerationStructureBarrier(cmdb, blas, AccelerationStructureUsageBit::kNone, AccelerationStructureUsageBit::kBuild);
-		cmdb->buildAccelerationStructure(blas);
+		cmdb->buildAccelerationStructure(blas.get());
 		setAccelerationStructureBarrier(cmdb, blas, AccelerationStructureUsageBit::kBuild, AccelerationStructureUsageBit::kAttach);
 
 		setAccelerationStructureBarrier(cmdb, tlas, AccelerationStructureUsageBit::kNone, AccelerationStructureUsageBit::kBuild);
-		cmdb->buildAccelerationStructure(tlas);
+		cmdb->buildAccelerationStructure(tlas.get());
 		setAccelerationStructureBarrier(cmdb, tlas, AccelerationStructureUsageBit::kBuild, AccelerationStructureUsageBit::kFragmentRead);
 
 		cmdb->flush();
@@ -2625,7 +2625,7 @@ void main()
 
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
 
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindShaderProgram(prog.get());
 		struct PC
 		{
 			Mat4 m_vp;
@@ -2637,7 +2637,7 @@ void main()
 
 		if(useRayTracing)
 		{
-			cmdb->bindAccelerationStructure(0, 0, tlas);
+			cmdb->bindAccelerationStructure(0, 0, tlas.get());
 		}
 
 		TexturePtr presentTex = g_gr->acquireNextPresentableTexture();
@@ -2645,8 +2645,8 @@ void main()
 
 		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSubresourceInfo{});
 
-		cmdb->beginRenderPass(fb, {TextureUsageBit::kFramebufferWrite}, {});
-		cmdb->drawArrays(PrimitiveTopology::kTriangleStrip, 4);
+		cmdb->beginRenderPass(fb.get(), {TextureUsageBit::kFramebufferWrite}, {});
+		cmdb->draw(PrimitiveTopology::kTriangleStrip, 4);
 		cmdb->endRenderPass();
 
 		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kPresent, TextureSubresourceInfo{});
@@ -2826,7 +2826,7 @@ void main()
 
 		ShaderPtr shader = createShader(src, ShaderType::kCompute, *g_gr);
 		ShaderProgramInitInfo sprogInit;
-		sprogInit.m_computeShader = shader;
+		sprogInit.m_computeShader = shader.get();
 		copyToPresentProg = g_gr->newShaderProgram(sprogInit);
 	}
 
@@ -2891,10 +2891,10 @@ void main()
 		{
 			AccelerationStructureInitInfo inf;
 			inf.m_type = AccelerationStructureType::kBottomLevel;
-			inf.m_bottomLevel.m_indexBuffer = g.m_indexBuffer;
+			inf.m_bottomLevel.m_indexBuffer = g.m_indexBuffer.get();
 			inf.m_bottomLevel.m_indexType = IndexType::kU16;
 			inf.m_bottomLevel.m_indexCount = g.m_indexCount;
-			inf.m_bottomLevel.m_positionBuffer = g.m_vertexBuffer;
+			inf.m_bottomLevel.m_positionBuffer = g.m_vertexBuffer.get();
 			inf.m_bottomLevel.m_positionCount = 8;
 			inf.m_bottomLevel.m_positionsFormat = Format::kR32G32B32_Sfloat;
 			inf.m_bottomLevel.m_positionStride = sizeof(Vec3);
@@ -3304,16 +3304,16 @@ void main()
 		ShaderPtr rayGenShader = createShader(String().sprintf("%s\n%s", commonSrc.cstr(), rayGenSrc.cstr()), ShaderType::kRayGen, *g_gr);
 
 		Array<RayTracingHitGroup, 4> hitGroups;
-		hitGroups[0].m_closestHitShader = lambertianShader;
-		hitGroups[1].m_closestHitShader = lambertianRoomShader;
-		hitGroups[2].m_closestHitShader = emissiveShader;
-		hitGroups[3].m_closestHitShader = shadowChitShader;
-		hitGroups[3].m_anyHitShader = shadowAhitShader;
+		hitGroups[0].m_closestHitShader = lambertianShader.get();
+		hitGroups[1].m_closestHitShader = lambertianRoomShader.get();
+		hitGroups[2].m_closestHitShader = emissiveShader.get();
+		hitGroups[3].m_closestHitShader = shadowChitShader.get();
+		hitGroups[3].m_anyHitShader = shadowAhitShader.get();
 
-		Array<ShaderPtr, 2> missShaders = {missShader, shadowMissShader};
+		Array<Shader*, 2> missShaders = {missShader.get(), shadowMissShader.get()};
 
 		// Add the same 2 times to test multiple ray gen shaders
-		Array<ShaderPtr, 2> rayGenShaders = {rayGenShader, rayGenShader};
+		Array<Shader*, 2> rayGenShaders = {rayGenShader.get(), rayGenShader.get()};
 
 		ShaderProgramInitInfo inf;
 		inf.m_rayTracingShaders.m_hitGroups = hitGroups;
@@ -3421,7 +3421,7 @@ void main()
 
 			for(const Geom& g : geometries)
 			{
-				cmdb->buildAccelerationStructure(g.m_blas);
+				cmdb->buildAccelerationStructure(g.m_blas.get());
 			}
 
 			for(const Geom& g : geometries)
@@ -3430,7 +3430,7 @@ void main()
 			}
 
 			setAccelerationStructureBarrier(cmdb, tlas, AccelerationStructureUsageBit::kNone, AccelerationStructureUsageBit::kBuild);
-			cmdb->buildAccelerationStructure(tlas);
+			cmdb->buildAccelerationStructure(tlas.get());
 			setAccelerationStructureBarrier(cmdb, tlas, AccelerationStructureUsageBit::kBuild, AccelerationStructureUsageBit::kTraceRaysRead);
 		}
 
@@ -3439,7 +3439,7 @@ void main()
 		{
 
 			TextureViewInitInfo inf;
-			inf.m_texture = presentTex;
+			inf.m_texture = presentTex.get();
 			presentView = g_gr->newTextureView(inf);
 		}
 
@@ -3447,10 +3447,10 @@ void main()
 		{
 
 			TextureViewInitInfo inf;
-			inf.m_texture = offscreenRts[i & 1];
+			inf.m_texture = offscreenRts[i & 1].get();
 			offscreenView = g_gr->newTextureView(inf);
 
-			inf.m_texture = offscreenRts[(i + 1) & 1];
+			inf.m_texture = offscreenRts[(i + 1) & 1].get();
 			offscreenHistoryView = g_gr->newTextureView(inf);
 		}
 
@@ -3458,13 +3458,13 @@ void main()
 		setTextureBarrier(cmdb, offscreenRts[(i + 1) & 1], TextureUsageBit::kImageComputeRead, TextureUsageBit::kImageTraceRaysRead,
 						  TextureSubresourceInfo());
 
-		cmdb->bindStorageBuffer(0, 0, modelBuffer, 0, kMaxPtrSize);
-		cmdb->bindStorageBuffer(0, 1, lightBuffer, 0, kMaxPtrSize);
-		cmdb->bindAccelerationStructure(1, 0, tlas);
-		cmdb->bindImage(1, 1, offscreenHistoryView);
-		cmdb->bindImage(1, 2, offscreenView);
+		cmdb->bindStorageBuffer(0, 0, modelBuffer.get(), 0, kMaxPtrSize);
+		cmdb->bindStorageBuffer(0, 1, lightBuffer.get(), 0, kMaxPtrSize);
+		cmdb->bindAccelerationStructure(1, 0, tlas.get());
+		cmdb->bindImage(1, 1, offscreenHistoryView.get());
+		cmdb->bindImage(1, 2, offscreenView.get());
 
-		cmdb->bindShaderProgram(rtProg);
+		cmdb->bindShaderProgram(rtProg.get());
 
 		PushConstants pc;
 		pc.m_vp = projMat * viewMat;
@@ -3475,17 +3475,17 @@ void main()
 		cmdb->setPushConstants(&pc, sizeof(pc));
 
 		const U32 sbtRecordSize = g_gr->getDeviceCapabilities().m_sbtRecordAlignment;
-		cmdb->traceRays(sbt, 0, sbtRecordSize, U32(GeomWhat::kCount) * 2, 2, WIDTH, HEIGHT, 1);
+		cmdb->traceRays(sbt.get(), 0, sbtRecordSize, U32(GeomWhat::kCount) * 2, 2, WIDTH, HEIGHT, 1);
 
 		// Copy to present
 		setTextureBarrier(cmdb, offscreenRts[i & 1], TextureUsageBit::kImageTraceRaysWrite, TextureUsageBit::kImageComputeRead,
 						  TextureSubresourceInfo());
 		setTextureBarrier(cmdb, presentTex, TextureUsageBit::kNone, TextureUsageBit::kImageComputeWrite, TextureSubresourceInfo());
 
-		cmdb->bindImage(0, 0, offscreenView);
-		cmdb->bindImage(0, 1, presentView);
+		cmdb->bindImage(0, 0, offscreenView.get());
+		cmdb->bindImage(0, 1, presentView.get());
 
-		cmdb->bindShaderProgram(copyToPresentProg);
+		cmdb->bindShaderProgram(copyToPresentProg.get());
 		const U32 sizeX = (WIDTH + 8 - 1) / 8;
 		const U32 sizeY = (HEIGHT + 8 - 1) / 8;
 		cmdb->dispatchCompute(sizeX, sizeY, 1);
@@ -3532,7 +3532,7 @@ void main()
 
 	ShaderPtr shader = createShader(PROG_SRC, ShaderType::kCompute, *g_gr);
 	ShaderProgramInitInfo sprogInit;
-	sprogInit.m_computeShader = shader;
+	sprogInit.m_computeShader = shader.get();
 	ShaderProgramPtr incrementProg = g_gr->newShaderProgram(sprogInit);
 
 	// Create the check program
@@ -3559,7 +3559,7 @@ void main()
 })";
 
 	shader = createShader(CHECK_SRC, ShaderType::kCompute, *g_gr);
-	sprogInit.m_computeShader = shader;
+	sprogInit.m_computeShader = shader.get();
 	ShaderProgramPtr checkProg = g_gr->newShaderProgram(sprogInit);
 
 	// Create buffers
@@ -3592,22 +3592,22 @@ void main()
 	CommandBufferInitInfo cinit;
 	cinit.m_flags = CommandBufferFlag::kComputeWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr incrementCmdb = g_gr->newCommandBuffer(cinit);
-	incrementCmdb->bindShaderProgram(incrementProg);
-	incrementCmdb->bindStorageBuffer(0, 0, atomicsBuffer, 0, kMaxPtrSize);
+	incrementCmdb->bindShaderProgram(incrementProg.get());
+	incrementCmdb->bindStorageBuffer(0, 0, atomicsBuffer.get(), 0, kMaxPtrSize);
 	incrementCmdb->dispatchCompute(ARRAY_SIZE / 8, 1, 1);
 
 	// Create the 2nd command buffer
 	cinit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr checkCmdb = g_gr->newCommandBuffer(cinit);
-	checkCmdb->bindShaderProgram(checkProg);
-	checkCmdb->bindStorageBuffer(0, 0, atomicsBuffer, 0, kMaxPtrSize);
+	checkCmdb->bindShaderProgram(checkProg.get());
+	checkCmdb->bindStorageBuffer(0, 0, atomicsBuffer.get(), 0, kMaxPtrSize);
 	checkCmdb->dispatchCompute(ARRAY_SIZE / 8, 1, 1);
 
 	// Create the 3rd command buffer
 	cinit.m_flags = CommandBufferFlag::kComputeWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr incrementCmdb2 = g_gr->newCommandBuffer(cinit);
-	incrementCmdb2->bindShaderProgram(incrementProg);
-	incrementCmdb2->bindStorageBuffer(0, 0, atomicsBuffer, 0, kMaxPtrSize);
+	incrementCmdb2->bindShaderProgram(incrementProg.get());
+	incrementCmdb2->bindStorageBuffer(0, 0, atomicsBuffer.get(), 0, kMaxPtrSize);
 	incrementCmdb2->dispatchCompute(ARRAY_SIZE / 8, 1, 1);
 
 	// Submit

Tests/Gr/GrTextureBuffer.cpp

@@ -32,7 +32,7 @@ void main()
 		ShaderPtr shader = createShader(shaderSrc, ShaderType::kCompute, *gr);
 
 		ShaderProgramInitInfo progInit;
-		progInit.m_computeShader = shader;
+		progInit.m_computeShader = shader.get();
 		ShaderProgramPtr prog = gr->newShaderProgram(progInit);
 
 		BufferInitInfo buffInit;
@@ -59,9 +59,9 @@ void main()
 		cmdbInit.m_flags = CommandBufferFlag::kSmallBatch | CommandBufferFlag::kGeneralWork;
 		CommandBufferPtr cmdb = gr->newCommandBuffer(cmdbInit);
 
-		cmdb->bindReadOnlyTextureBuffer(0, 0, texBuff, 0, kMaxPtrSize, Format::kR8G8B8A8_Snorm);
-		cmdb->bindStorageBuffer(0, 1, storageBuff, 0, kMaxPtrSize);
-		cmdb->bindShaderProgram(prog);
+		cmdb->bindReadOnlyTextureBuffer(0, 0, texBuff.get(), 0, kMaxPtrSize, Format::kR8G8B8A8_Snorm);
+		cmdb->bindStorageBuffer(0, 1, storageBuff.get(), 0, kMaxPtrSize);
+		cmdb->bindShaderProgram(prog.get());
 		cmdb->dispatchCompute(1, 1, 1);
 		cmdb->flush();
 		gr->finish();

Tests/Ui/Ui.cpp

@@ -105,7 +105,7 @@ ANKI_TEST(Ui, Ui)
 			FramebufferPtr fb;
 			{
 				TextureViewInitInfo init;
-				init.m_texture = presentTex;
+				init.m_texture = presentTex.get();
 				TextureViewPtr view = gr->newTextureView(init);
 
 				FramebufferInitInfo fbinit;
@@ -126,7 +126,7 @@ ANKI_TEST(Ui, Ui)
 			barrier.m_texture = presentTex.get();
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
-			cmdb->beginRenderPass(fb, {{TextureUsageBit::kFramebufferWrite}}, {});
+			cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kFramebufferWrite}}, {});
 			canvas->appendToCommandBuffer(cmdb);
 			cmdb->endRenderPass();
 

Tools/Image/ImageViewerMain.cpp

@@ -31,7 +31,7 @@ public:
 	{
 		if(!m_textureView.isCreated())
 		{
-			m_textureView = m_imageResource->getTextureView();
+			m_textureView.reset(&m_imageResource->getTextureView());
 		}
 
 		return Error::kNone;
@@ -53,7 +53,7 @@ private:
 
 	void draw(CanvasPtr& canvas)
 	{
-		const Texture& grTex = *m_imageResource->getTexture().get();
+		const Texture& grTex = m_imageResource->getTexture();
 		const U32 colorComponentCount = getFormatInfo(grTex.getFormat()).m_componentCount;
 		ANKI_ASSERT(grTex.getTextureType() == TextureType::k2D || grTex.getTextureType() == TextureType::k3D);
 
@@ -64,7 +64,7 @@ private:
 
 			const ShaderProgramResourceVariant* variant;
 			m_imageProgram->getOrCreateVariant(variantInit, variant);
-			m_imageGrProgram = variant->getProgram();
+			m_imageGrProgram.reset(&variant->getProgram());
 		}
 
 		ImGui::Begin("Console", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove);
@@ -143,7 +143,7 @@ private:
 			if(lastCrntMip != m_crntMip)
 			{
 				// Re-create the image view
-				TextureViewInitInfo viewInitInf(m_imageResource->getTexture());
+				TextureViewInitInfo viewInitInf(&m_imageResource->getTexture());
 				viewInitInf.m_firstMipmap = m_crntMip;
 				viewInitInf.m_mipmapCount = 1;
 				m_textureView = GrManager::getSingleton().newTextureView(viewInitInf);
@@ -287,8 +287,8 @@ public:
 
 		// Change window name
 		String title;
-		title.sprintf("%s %u x %u Mips %u Format %s", argv[1], image->getWidth(), image->getHeight(), image->getTexture()->getMipmapCount(),
-					  getFormatInfo(image->getTexture()->getFormat()).m_name);
+		title.sprintf("%s %u x %u Mips %u Format %s", argv[1], image->getWidth(), image->getHeight(), image->getTexture().getMipmapCount(),
+					  getFormatInfo(image->getTexture().getFormat()).m_name);
 		NativeWindow::getSingleton().setWindowTitle(title);
 
 		// Create the node