Some renaming

AnKi/Gr/D3D/D3DTexture.cpp

@@ -22,7 +22,7 @@ Texture* Texture::newInstance(const TextureInitInfo& init)
 	return impl;
 }
 
-U32 Texture::getOrCreateBindlessTextureIndex(const TextureSubresourceDescriptor& subresource)
+U32 Texture::getOrCreateBindlessTextureIndex(const TextureSubresourceDesc& subresource)
 {
 	ANKI_D3D_SELF(TextureImpl);
 
@@ -171,14 +171,14 @@ Error TextureImpl::initInternal(ID3D12Resource* external, const TextureInitInfo&
 	// Create the default views
 	if(!!(m_usage & TextureUsageBit::kAllFramebuffer))
 	{
-		const TextureView tview(this, TextureSubresourceDescriptor::firstSurface());
+		const TextureView tview(this, TextureSubresourceDesc::firstSurface());
 		initView(tview.getSubresource(), TextureUsageBit::kAllFramebuffer, m_firstSurfaceRtvOrDsv);
 		m_firstSurfaceRtvOrDsvSubresource = tview.getSubresource();
 	}
 
 	if(!!(m_usage & TextureUsageBit::kAllSampled))
 	{
-		const TextureView tview(this, TextureSubresourceDescriptor::all());
+		const TextureView tview(this, TextureSubresourceDesc::all());
 		initView(tview.getSubresource(), TextureUsageBit::kAllSampled, m_wholeTextureSrv);
 		m_wholeTextureSrvSubresource = tview.getSubresource();
 	}
@@ -186,7 +186,7 @@ Error TextureImpl::initInternal(ID3D12Resource* external, const TextureInitInfo&
 	return Error::kNone;
 }
 
-void TextureImpl::initView(const TextureSubresourceDescriptor& subresource, TextureUsageBit usage, View& view) const
+void TextureImpl::initView(const TextureSubresourceDesc& subresource, TextureUsageBit usage, View& view) const
 {
 	ANKI_ASSERT(!!(m_usage & usage));
 
@@ -452,7 +452,7 @@ void TextureImpl::initView(const TextureSubresourceDescriptor& subresource, Text
 	}
 }
 
-const TextureImpl::View& TextureImpl::getOrCreateView(const TextureSubresourceDescriptor& subresource, TextureUsageBit usage) const
+const TextureImpl::View& TextureImpl::getOrCreateView(const TextureSubresourceDesc& subresource, TextureUsageBit usage) const
 {
 	ANKI_ASSERT(subresource == TextureView(this, subresource).getSubresource() && "Should have been sanitized");
 	ANKI_ASSERT(!!(usage & m_usage));
@@ -473,7 +473,7 @@ const TextureImpl::View& TextureImpl::getOrCreateView(const TextureSubresourceDe
 	class
 	{
 	public:
-		TextureSubresourceDescriptor m_subresource;
+		TextureSubresourceDesc m_subresource;
 		TextureUsageBit m_usage;
 	} toHash = {subresource, usage};
 	ANKI_END_PACKED_STRUCT
@@ -513,8 +513,7 @@ const TextureImpl::View& TextureImpl::getOrCreateView(const TextureSubresourceDe
 	return nview;
 }
 
-D3D12_TEXTURE_BARRIER TextureImpl::computeBarrierInfo(TextureUsageBit before, TextureUsageBit after,
-													  const TextureSubresourceDescriptor& subresource) const
+D3D12_TEXTURE_BARRIER TextureImpl::computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDesc& subresource) const
 {
 	ANKI_ASSERT((m_usage & before) == before);
 	ANKI_ASSERT((m_usage & after) == after);

AnKi/Gr/D3D/D3DTexture.h

@@ -37,35 +37,35 @@ public:
 		return initInternal(external, init);
 	}
 
-	DescriptorHeapHandle getOrCreateRtv(const TextureSubresourceDescriptor& subresource) const
+	DescriptorHeapHandle getOrCreateRtv(const TextureSubresourceDesc& subresource) const
 	{
 		const View& e = getOrCreateView(subresource, TextureUsageBit::kAllFramebuffer);
 		ANKI_ASSERT(e.m_handle.isCreated());
 		return e.m_handle;
 	}
 
-	DescriptorHeapHandle getOrCreateDsv(const TextureSubresourceDescriptor& subresource, TextureUsageBit usage) const
+	DescriptorHeapHandle getOrCreateDsv(const TextureSubresourceDesc& subresource, TextureUsageBit usage) const
 	{
 		const View& e = getOrCreateView(subresource, usage);
 		ANKI_ASSERT(e.m_handle.isCreated());
 		return e.m_handle;
 	}
 
-	DescriptorHeapHandle getOrCreateSrv(const TextureSubresourceDescriptor& subresource) const
+	DescriptorHeapHandle getOrCreateSrv(const TextureSubresourceDesc& subresource) const
 	{
 		const View& e = getOrCreateView(subresource, TextureUsageBit::kAllSampled);
 		ANKI_ASSERT(e.m_handle.isCreated());
 		return e.m_handle;
 	}
 
-	DescriptorHeapHandle getOrCreateUav(const TextureSubresourceDescriptor& subresource) const
+	DescriptorHeapHandle getOrCreateUav(const TextureSubresourceDesc& subresource) const
 	{
 		const View& e = getOrCreateView(subresource, TextureUsageBit::kAllStorage);
 		ANKI_ASSERT(e.m_handle.isCreated());
 		return e.m_handle;
 	}
 
-	U32 calcD3DSubresourceIndex(const TextureSubresourceDescriptor& subresource) const
+	U32 calcD3DSubresourceIndex(const TextureSubresourceDesc& subresource) const
 	{
 		const TextureView view(this, subresource);
 
@@ -77,7 +77,7 @@ public:
 		return view.getFirstMipmap() + (arraySlice * m_mipCount) + (planeSlice * m_mipCount * arraySize);
 	}
 
-	D3D12_TEXTURE_BARRIER computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDescriptor& subresource) const;
+	D3D12_TEXTURE_BARRIER computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDesc& subresource) const;
 
 	ID3D12Resource& getD3DResource() const
 	{
@@ -126,14 +126,14 @@ private:
 	// Cache a few common views
 	View m_wholeTextureSrv;
 	View m_firstSurfaceRtvOrDsv;
-	TextureSubresourceDescriptor m_wholeTextureSrvSubresource = TextureSubresourceDescriptor::all();
-	TextureSubresourceDescriptor m_firstSurfaceRtvOrDsvSubresource = TextureSubresourceDescriptor::all();
+	TextureSubresourceDesc m_wholeTextureSrvSubresource = TextureSubresourceDesc::all();
+	TextureSubresourceDesc m_firstSurfaceRtvOrDsvSubresource = TextureSubresourceDesc::all();
 
 	Error initInternal(ID3D12Resource* external, const TextureInitInfo& init);
 
-	const View& getOrCreateView(const TextureSubresourceDescriptor& subresource, TextureUsageBit usage) const;
+	const View& getOrCreateView(const TextureSubresourceDesc& subresource, TextureUsageBit usage) const;
 
-	void initView(const TextureSubresourceDescriptor& subresource, TextureUsageBit usage, View& view) const;
+	void initView(const TextureSubresourceDesc& subresource, TextureUsageBit usage, View& view) const;
 
 	void computeBarrierInfo(TextureUsageBit usage, D3D12_BARRIER_SYNC& stages, D3D12_BARRIER_ACCESS& accesses) const;
 

AnKi/Gr/RenderGraph.cpp

@@ -64,9 +64,9 @@ public:
 	U32 m_idx;
 	TextureUsageBit m_usageBefore;
 	TextureUsageBit m_usageAfter;
-	TextureSubresourceDescriptor m_subresource;
+	TextureSubresourceDesc m_subresource;
 
-	TextureBarrier(U32 rtIdx, TextureUsageBit usageBefore, TextureUsageBit usageAfter, const TextureSubresourceDescriptor& sub)
+	TextureBarrier(U32 rtIdx, TextureUsageBit usageBefore, TextureUsageBit usageAfter, const TextureSubresourceDesc& sub)
 		: m_idx(rtIdx)
 		, m_usageBefore(usageBefore)
 		, m_usageAfter(usageAfter)
@@ -342,7 +342,7 @@ TexturePtr RenderGraph::getOrCreateRenderTarget(const TextureInitInfo& initInf,
 	return tex;
 }
 
-Bool RenderGraph::passADependsOnB(const RenderPassDescriptionBase& a, const RenderPassDescriptionBase& b)
+Bool RenderGraph::passADependsOnB(const RenderPassBase& a, const RenderPassBase& b)
 {
 	// Render targets
 	{
@@ -494,7 +494,7 @@ Bool RenderGraph::passHasUnmetDependencies(const BakeContext& ctx, U32 passIdx)
 	return depends;
 }
 
-RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription& descr, StackMemoryPool& pool)
+RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphBuilder& descr, StackMemoryPool& pool)
 {
 	// Allocate
 	BakeContext* ctx = anki::newInstance<BakeContext>(pool, &pool);
@@ -504,7 +504,7 @@ RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription&
 	for(U32 rtIdx = 0; rtIdx < descr.m_renderTargets.getSize(); ++rtIdx)
 	{
 		RT& outRt = *ctx->m_rts.emplaceBack(&pool);
-		const RenderGraphDescription::RT& inRt = descr.m_renderTargets[rtIdx];
+		const RenderGraphBuilder::RT& inRt = descr.m_renderTargets[rtIdx];
 
 		const Bool imported = inRt.m_importedTex.isCreated();
 		if(imported)
@@ -586,7 +586,7 @@ RenderGraph::BakeContext* RenderGraph::newContext(const RenderGraphDescription&
 	return ctx;
 }
 
-void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphDescription& descr)
+void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphBuilder& descr)
 {
 	BakeContext& ctx = *m_ctx;
 	const U32 passCount = descr.m_passes.getSize();
@@ -595,7 +595,7 @@ void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphDescription& descr
 	ctx.m_passes.resizeStorage(passCount);
 	for(U32 passIdx = 0; passIdx < passCount; ++passIdx)
 	{
-		const RenderPassDescriptionBase& inPass = *descr.m_passes[passIdx];
+		const RenderPassBase& inPass = *descr.m_passes[passIdx];
 		Pass& outPass = *ctx.m_passes.emplaceBack(ctx.m_as.getMemoryPool().m_pool);
 
 		outPass.m_callback = inPass.m_callback;
@@ -618,7 +618,7 @@ void RenderGraph::initRenderPassesAndSetDeps(const RenderGraphDescription& descr
 		U32 prevPassIdx = passIdx;
 		while(prevPassIdx--)
 		{
-			const RenderPassDescriptionBase& prevPass = *descr.m_passes[prevPassIdx];
+			const RenderPassBase& prevPass = *descr.m_passes[prevPassIdx];
 
 			if(passADependsOnB(inPass, prevPass))
 			{
@@ -660,7 +660,7 @@ void RenderGraph::initBatches()
 	}
 }
 
-void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
+void RenderGraph::initGraphicsPasses(const RenderGraphBuilder& descr)
 {
 	BakeContext& ctx = *m_ctx;
 	const U32 passCount = descr.m_passes.getSize();
@@ -668,13 +668,13 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 
 	for(U32 passIdx = 0; passIdx < passCount; ++passIdx)
 	{
-		const RenderPassDescriptionBase& baseInPass = *descr.m_passes[passIdx];
+		const RenderPassBase& baseInPass = *descr.m_passes[passIdx];
 		Pass& outPass = ctx.m_passes[passIdx];
 
 		// Create command buffers and framebuffer
-		if(baseInPass.m_type == RenderPassDescriptionBase::Type::kGraphics)
+		if(baseInPass.m_type == RenderPassBase::Type::kGraphics)
 		{
-			const GraphicsRenderPassDescription& inPass = static_cast<const GraphicsRenderPassDescription&>(baseInPass);
+			const GraphicsRenderPass& inPass = static_cast<const GraphicsRenderPass&>(baseInPass);
 
 			if(inPass.hasRenderpass())
 			{
@@ -684,7 +684,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 				// Init the usage bits
 				for(U32 i = 0; i < inPass.m_colorRtCount; ++i)
 				{
-					const RenderTargetInfo& inAttachment = inPass.m_rts[i];
+					const GraphicsRenderPassTargetDesc& inAttachment = inPass.m_rts[i];
 					RenderTarget& outAttachment = outPass.m_beginRenderpassInfo.m_colorRts[i];
 
 					getCrntUsage(inAttachment.m_handle, outPass.m_batchIdx, inAttachment.m_subresource, outAttachment.m_usage);
@@ -699,7 +699,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 
 				if(!!inPass.m_rts[kMaxColorRenderTargets].m_subresource.m_depthStencilAspect)
 				{
-					const RenderTargetInfo& inAttachment = inPass.m_rts[kMaxColorRenderTargets];
+					const GraphicsRenderPassTargetDesc& inAttachment = inPass.m_rts[kMaxColorRenderTargets];
 					RenderTarget& outAttachment = outPass.m_beginRenderpassInfo.m_dsRt;
 
 					getCrntUsage(inAttachment.m_handle, outPass.m_batchIdx, inAttachment.m_subresource, outAttachment.m_usage);
@@ -716,7 +716,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 
 				if(inPass.m_vrsRtTexelSizeX > 0)
 				{
-					const RenderTargetInfo& inAttachment = inPass.m_rts[kMaxColorRenderTargets + 1];
+					const GraphicsRenderPassTargetDesc& inAttachment = inPass.m_rts[kMaxColorRenderTargets + 1];
 
 					outPass.m_beginRenderpassInfo.m_vrsRt =
 						TextureView(m_ctx->m_rts[inAttachment.m_handle.m_idx].m_texture.get(), inAttachment.m_subresource);
@@ -731,7 +731,7 @@ void RenderGraph::initGraphicsPasses(const RenderGraphDescription& descr)
 }
 
 template<typename TFunc>
-void RenderGraph::iterateSurfsOrVolumes(const Texture& tex, const TextureSubresourceDescriptor& subresource, TFunc func)
+void RenderGraph::iterateSurfsOrVolumes(const Texture& tex, const TextureSubresourceDesc& subresource, TFunc func)
 {
 	subresource.validate(tex);
 	const U32 faceCount = textureTypeIsCube(tex.getTextureType()) ? 6 : 1;
@@ -747,7 +747,7 @@ void RenderGraph::iterateSurfsOrVolumes(const Texture& tex, const TextureSubreso
 					// Compute surf or vol idx
 					const U32 idx = (faceCount * tex.getLayerCount()) * mip + faceCount * layer + face;
 
-					if(!func(idx, TextureSubresourceDescriptor::surface(mip, face, layer, subresource.m_depthStencilAspect)))
+					if(!func(idx, TextureSubresourceDesc::surface(mip, face, layer, subresource.m_depthStencilAspect)))
 					{
 						return;
 					}
@@ -773,7 +773,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 TextureSubresourceDescriptor& subresource) {
+	iterateSurfsOrVolumes(*rt.m_texture, dep.m_texture.m_subresource, [&](U32 surfOrVolIdx, const TextureSubresourceDesc& subresource) {
 		TextureUsageBit& crntUsage = rt.m_surfOrVolUsages[surfOrVolIdx];
 
 		const Bool skipBarrier = crntUsage == depUsage && !(crntUsage & TextureUsageBit::kAllWrite);
@@ -815,7 +815,7 @@ void RenderGraph::setTextureBarrier(Batch& batch, const RenderPassDependency& de
 	});
 }
 
-void RenderGraph::setBatchBarriers(const RenderGraphDescription& descr)
+void RenderGraph::setBatchBarriers(const RenderGraphBuilder& descr)
 {
 	BakeContext& ctx = *m_ctx;
 
@@ -828,7 +828,7 @@ void RenderGraph::setBatchBarriers(const RenderGraphDescription& descr)
 		// For all passes of that batch
 		for(U32 passIdx : batch.m_passIndices)
 		{
-			const RenderPassDescriptionBase& pass = *descr.m_passes[passIdx];
+			const RenderPassBase& pass = *descr.m_passes[passIdx];
 
 			// Do textures
 			for(const RenderPassDependency& dep : pass.m_rtDeps)
@@ -1031,7 +1031,7 @@ void RenderGraph::sortBatchPasses()
 	}
 }
 
-void RenderGraph::compileNewGraph(const RenderGraphDescription& descr, StackMemoryPool& pool)
+void RenderGraph::compileNewGraph(const RenderGraphBuilder& descr, StackMemoryPool& pool)
 {
 	ANKI_TRACE_SCOPED_EVENT(GrRenderGraphCompile);
 
@@ -1263,7 +1263,7 @@ void RenderGraph::recordAndSubmitCommandBuffers(FencePtr* optionalFence)
 	}
 }
 
-void RenderGraph::getCrntUsage(RenderTargetHandle handle, U32 batchIdx, const TextureSubresourceDescriptor& subresource, TextureUsageBit& usage) const
+void RenderGraph::getCrntUsage(RenderTargetHandle handle, U32 batchIdx, const TextureSubresourceDesc& subresource, TextureUsageBit& usage) const
 {
 	usage = TextureUsageBit::kNone;
 	const Batch& batch = m_ctx->m_batches[batchIdx];
@@ -1476,7 +1476,7 @@ StringRaii RenderGraph::asUsageToStr(StackMemoryPool& pool, AccelerationStructur
 	return str;
 }
 
-Error RenderGraph::dumpDependencyDotFile(const RenderGraphDescription& descr, const BakeContext& ctx, CString path) const
+Error RenderGraph::dumpDependencyDotFile(const RenderGraphBuilder& descr, const BakeContext& ctx, CString path) const
 {
 	ANKI_GR_LOGW("Running with debug code");
 
@@ -1503,7 +1503,7 @@ Error RenderGraph::dumpDependencyDotFile(const RenderGraphDescription& descr, co
 			CString passName = descr.m_passes[passIdx]->m_name.toCString();
 
 			slist.pushBackSprintf("\t\"%s\"[color=%s,style=%s,shape=box];\n", passName.cstr(), COLORS[batchIdx % COLORS.getSize()],
-								  (descr.m_passes[passIdx]->m_type == RenderPassDescriptionBase::Type::kGraphics) ? "bold" : "dashed");
+								  (descr.m_passes[passIdx]->m_type == RenderPassBase::Type::kGraphics) ? "bold" : "dashed");
 
 			for(U32 depIdx : ctx.m_passes[passIdx].m_dependsOn)
 			{
@@ -1596,7 +1596,7 @@ Error RenderGraph::dumpDependencyDotFile(const RenderGraphDescription& descr, co
 
 		for(U32 passIdx : batch.m_passIndices)
 		{
-			const RenderPassDescriptionBase& pass = *descr.m_passes[passIdx];
+			const RenderPassBase& pass = *descr.m_passes[passIdx];
 			StringRaii passName(&pool);
 			passName.sprintf("%s pass", pass.m_name.cstr());
 			slist.pushBackSprintf("\t\"%s\"[color=%s,style=bold];\n", passName.cstr(), COLORS[batchIdx % COLORS.getSize()]);

AnKi/Gr/RenderGraph.h

@@ -20,7 +20,7 @@ namespace anki {
 
 // Forward
 class RenderGraph;
-class RenderGraphDescription;
+class RenderGraphBuilder;
 
 /// @addtogroup graphics
 /// @{
@@ -34,13 +34,13 @@ constexpr U32 kMaxRenderGraphAccelerationStructures = 32;
 /// @}
 
 /// Render target handle used in the RenderGraph.
-/// @memberof RenderGraphDescription
+/// @memberof RenderGraphBuilder
 class RenderGraphGrObjectHandle
 {
 	friend class RenderPassDependency;
-	friend class RenderGraphDescription;
+	friend class RenderGraphBuilder;
 	friend class RenderGraph;
-	friend class RenderPassDescriptionBase;
+	friend class RenderPassBase;
 
 public:
 	Bool operator==(const RenderGraphGrObjectHandle& b) const
@@ -63,35 +63,35 @@ private:
 };
 
 /// Render target (TexturePtr) handle.
-/// @memberof RenderGraphDescription
+/// @memberof RenderGraphBuilder
 class RenderTargetHandle : public RenderGraphGrObjectHandle
 {
 };
 
 /// BufferPtr handle.
-/// @memberof RenderGraphDescription
+/// @memberof RenderGraphBuilder
 class BufferHandle : public RenderGraphGrObjectHandle
 {
 };
 
 /// AccelerationStructurePtr handle.
-/// @memberof RenderGraphDescription
+/// @memberof RenderGraphBuilder
 class AccelerationStructureHandle : public RenderGraphGrObjectHandle
 {
 };
 
 /// Describes the render target.
-/// @memberof RenderGraphDescription
-class RenderTargetDescription : public TextureInitInfo
+/// @memberof RenderGraphBuilder
+class RenderTargetDesc : public TextureInitInfo
 {
-	friend class RenderGraphDescription;
+	friend class RenderGraphBuilder;
 
 public:
-	RenderTargetDescription()
+	RenderTargetDesc()
 	{
 	}
 
-	RenderTargetDescription(CString name)
+	RenderTargetDesc(CString name)
 		: TextureInitInfo(name)
 	{
 	}
@@ -123,9 +123,9 @@ public:
 
 	void getBufferState(BufferHandle handle, Buffer*& buff, PtrSize& offset, PtrSize& range) const;
 
-	void getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceDescriptor& subresource, Texture*& tex) const;
+	void getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceDesc& subresource, Texture*& tex) const;
 
-	TextureView createTextureView(RenderTargetHandle handle, const TextureSubresourceDescriptor& subresource) const
+	TextureView createTextureView(RenderTargetHandle handle, const TextureSubresourceDesc& subresource) const
 	{
 		Texture* tex;
 		getRenderTargetState(handle, subresource, tex);
@@ -133,7 +133,7 @@ public:
 	}
 
 	/// Convenience method.
-	void bindTexture(Register reg, RenderTargetHandle handle, const TextureSubresourceDescriptor& subresource)
+	void bindTexture(Register reg, RenderTargetHandle handle, const TextureSubresourceDesc& subresource)
 	{
 		Texture* tex;
 		getRenderTargetState(handle, subresource, tex);
@@ -143,7 +143,7 @@ public:
 	/// Convenience method to bind the whole texture.
 	void bindTexture(Register reg, RenderTargetHandle handle)
 	{
-		const TextureSubresourceDescriptor subresource = TextureSubresourceDescriptor::all();
+		const TextureSubresourceDesc subresource = TextureSubresourceDesc::all();
 		Texture* tex;
 		getRenderTargetState(handle, subresource, tex); // Doesn't care about the aspect so it's OK
 		m_commandBuffer->bindTexture(reg, TextureView(tex, subresource));
@@ -179,15 +179,15 @@ private:
 };
 
 /// RenderGraph pass dependency.
-/// @memberof RenderGraphDescription
+/// @memberof RenderGraphBuilder
 class RenderPassDependency
 {
 	friend class RenderGraph;
-	friend class RenderPassDescriptionBase;
+	friend class RenderPassBase;
 
 public:
 	/// Dependency to a texture subresource.
-	RenderPassDependency(RenderTargetHandle handle, TextureUsageBit usage, const TextureSubresourceDescriptor& subresource)
+	RenderPassDependency(RenderTargetHandle handle, TextureUsageBit usage, const TextureSubresourceDesc& subresource)
 		: m_texture({handle, usage, subresource})
 		, m_type(Type::kTexture)
 	{
@@ -214,7 +214,7 @@ private:
 	public:
 		RenderTargetHandle m_handle;
 		TextureUsageBit m_usage;
-		TextureSubresourceDescriptor m_subresource = TextureSubresourceDescriptor::all();
+		TextureSubresourceDesc m_subresource = TextureSubresourceDesc::all();
 	};
 
 	class BufferInfo
@@ -249,11 +249,11 @@ private:
 };
 
 /// The base of compute/transfer and graphics renderpasses for RenderGraph.
-/// @memberof RenderGraphDescription
-class RenderPassDescriptionBase
+/// @memberof RenderGraphBuilder
+class RenderPassBase
 {
 	friend class RenderGraph;
-	friend class RenderGraphDescription;
+	friend class RenderGraphBuilder;
 
 public:
 	template<typename TFunc>
@@ -262,14 +262,14 @@ public:
 		m_callback = {func, m_rtDeps.getMemoryPool().m_pool};
 	}
 
-	void newTextureDependency(RenderTargetHandle handle, TextureUsageBit usage, const TextureSubresourceDescriptor& subresource)
+	void newTextureDependency(RenderTargetHandle handle, TextureUsageBit usage, const TextureSubresourceDesc& subresource)
 	{
 		newDependency<RenderPassDependency::Type::kTexture>(RenderPassDependency(handle, usage, subresource));
 	}
 
 	void newTextureDependency(RenderTargetHandle handle, TextureUsageBit usage, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 	{
-		newDependency<RenderPassDependency::Type::kTexture>(RenderPassDependency(handle, usage, TextureSubresourceDescriptor::all(aspect)));
+		newDependency<RenderPassDependency::Type::kTexture>(RenderPassDependency(handle, usage, TextureSubresourceDesc::all(aspect)));
 	}
 
 	void newBufferDependency(BufferHandle handle, BufferUsageBit usage)
@@ -286,12 +286,12 @@ protected:
 	enum class Type : U8
 	{
 		kGraphics,
-		kNoGraphics
+		kNonGraphics
 	};
 
 	Type m_type;
 
-	RenderGraphDescription* m_descr;
+	RenderGraphBuilder* m_descr;
 
 	Function<void(RenderPassWorkContext&), MemoryPoolPtrWrapper<StackMemoryPool>> m_callback;
 
@@ -308,7 +308,7 @@ protected:
 
 	BaseString<MemoryPoolPtrWrapper<StackMemoryPool>> m_name;
 
-	RenderPassDescriptionBase(Type t, RenderGraphDescription* descr, StackMemoryPool* pool)
+	RenderPassBase(Type t, RenderGraphBuilder* descr, StackMemoryPool* pool)
 		: m_type(t)
 		, m_descr(descr)
 		, m_rtDeps(pool)
@@ -333,13 +333,13 @@ protected:
 	void newDependency(const RenderPassDependency& dep);
 };
 
-/// Renderpass attachment info. Used in GraphicsRenderPassDescription::setRenderpassInfo. It mirrors the RenderPass.
-/// @memberof GraphicsRenderPassDescription
-class RenderTargetInfo
+/// Renderpass attachment info. Used in GraphicsRenderPass::setRenderpassInfo. It mirrors the RenderPass.
+/// @memberof GraphicsRenderPass
+class GraphicsRenderPassTargetDesc
 {
 public:
 	RenderTargetHandle m_handle;
-	TextureSubresourceDescriptor m_subresource = TextureSubresourceDescriptor::firstSurface();
+	TextureSubresourceDesc m_subresource = TextureSubresourceDesc::firstSurface();
 
 	RenderTargetLoadOperation m_loadOperation = RenderTargetLoadOperation::kDontCare;
 	RenderTargetStoreOperation m_storeOperation = RenderTargetStoreOperation::kStore;
@@ -349,41 +349,41 @@ public:
 
 	ClearValue m_clearValue;
 
-	RenderTargetInfo() = default;
+	GraphicsRenderPassTargetDesc() = default;
 
-	RenderTargetInfo(RenderTargetHandle handle)
+	GraphicsRenderPassTargetDesc(RenderTargetHandle handle)
 		: m_handle(handle)
 	{
 	}
 };
 
 /// A graphics render pass for RenderGraph.
-/// @memberof RenderGraphDescription
-class GraphicsRenderPassDescription : public RenderPassDescriptionBase
+/// @memberof RenderGraphBuilder
+class GraphicsRenderPass : public RenderPassBase
 {
-	friend class RenderGraphDescription;
+	friend class RenderGraphBuilder;
 	friend class RenderGraph;
 
 public:
-	GraphicsRenderPassDescription(RenderGraphDescription* descr, StackMemoryPool* pool)
-		: RenderPassDescriptionBase(Type::kGraphics, descr, pool)
+	GraphicsRenderPass(RenderGraphBuilder* descr, StackMemoryPool* pool)
+		: RenderPassBase(Type::kGraphics, descr, pool)
 	{
 	}
 
-	void setRenderpassInfo(ConstWeakArray<RenderTargetInfo> colorRts, const RenderTargetInfo* depthStencilRt = nullptr, U32 minx = 0, U32 miny = 0,
-						   U32 width = kMaxU32, U32 height = kMaxU32, const RenderTargetHandle* vrsRt = nullptr, U8 vrsRtTexelSizeX = 0,
-						   U8 vrsRtTexelSizeY = 0);
+	void setRenderpassInfo(ConstWeakArray<GraphicsRenderPassTargetDesc> colorRts, const GraphicsRenderPassTargetDesc* depthStencilRt = nullptr,
+						   U32 minx = 0, U32 miny = 0, U32 width = kMaxU32, U32 height = kMaxU32, const RenderTargetHandle* vrsRt = nullptr,
+						   U8 vrsRtTexelSizeX = 0, U8 vrsRtTexelSizeY = 0);
 
-	void setRenderpassInfo(std::initializer_list<RenderTargetInfo> colorRts, const RenderTargetInfo* depthStencilRt = nullptr, U32 minx = 0,
-						   U32 miny = 0, U32 width = kMaxU32, U32 height = kMaxU32, const RenderTargetHandle* vrsRt = nullptr, U8 vrsRtTexelSizeX = 0,
-						   U8 vrsRtTexelSizeY = 0)
+	void setRenderpassInfo(std::initializer_list<GraphicsRenderPassTargetDesc> colorRts, const GraphicsRenderPassTargetDesc* depthStencilRt = nullptr,
+						   U32 minx = 0, U32 miny = 0, U32 width = kMaxU32, U32 height = kMaxU32, const RenderTargetHandle* vrsRt = nullptr,
+						   U8 vrsRtTexelSizeX = 0, U8 vrsRtTexelSizeY = 0)
 	{
-		ConstWeakArray<RenderTargetInfo> colorRtsArr(colorRts.begin(), U32(colorRts.size()));
+		ConstWeakArray<GraphicsRenderPassTargetDesc> colorRtsArr(colorRts.begin(), U32(colorRts.size()));
 		setRenderpassInfo(colorRtsArr, depthStencilRt, minx, miny, width, height, vrsRt, vrsRtTexelSizeX, vrsRtTexelSizeY);
 	}
 
 private:
-	Array<RenderTargetInfo, kMaxColorRenderTargets + 2> m_rts;
+	Array<GraphicsRenderPassTargetDesc, kMaxColorRenderTargets + 2> m_rts;
 	Array<U32, 4> m_rpassRenderArea = {};
 	U8 m_colorRtCount = 0;
 	U8 m_vrsRtTexelSizeX = 0;
@@ -396,38 +396,38 @@ private:
 };
 
 /// A compute render pass for RenderGraph.
-/// @memberof RenderGraphDescription
-class ComputeRenderPassDescription : public RenderPassDescriptionBase
+/// @memberof RenderGraphBuilder
+class NonGraphicsRenderPass : public RenderPassBase
 {
-	friend class RenderGraphDescription;
+	friend class RenderGraphBuilder;
 
 public:
-	ComputeRenderPassDescription(RenderGraphDescription* descr, StackMemoryPool* pool)
-		: RenderPassDescriptionBase(Type::kNoGraphics, descr, pool)
+	NonGraphicsRenderPass(RenderGraphBuilder* descr, StackMemoryPool* pool)
+		: RenderPassBase(Type::kNonGraphics, descr, pool)
 	{
 	}
 };
 
 /// Builds the description of the frame's render passes and their interactions.
 /// @memberof RenderGraph
-class RenderGraphDescription
+class RenderGraphBuilder
 {
 	friend class RenderGraph;
-	friend class RenderPassDescriptionBase;
+	friend class RenderPassBase;
 
 public:
-	RenderGraphDescription(StackMemoryPool* pool)
+	RenderGraphBuilder(StackMemoryPool* pool)
 		: m_pool(pool)
 	{
 	}
 
-	~RenderGraphDescription();
+	~RenderGraphBuilder();
 
 	/// Create a new graphics render pass.
-	GraphicsRenderPassDescription& newGraphicsRenderPass(CString name);
+	GraphicsRenderPass& newGraphicsRenderPass(CString name);
 
 	/// Create a new compute render pass.
-	ComputeRenderPassDescription& newComputeRenderPass(CString name);
+	NonGraphicsRenderPass& newNonGraphicsRenderPass(CString name);
 
 	/// Import an existing render target and let the render graph know about it's up-to-date usage.
 	RenderTargetHandle importRenderTarget(Texture* tex, TextureUsageBit usage);
@@ -436,7 +436,7 @@ public:
 	RenderTargetHandle importRenderTarget(Texture* tex);
 
 	/// Get or create a new render target.
-	RenderTargetHandle newRenderTarget(const RenderTargetDescription& initInf);
+	RenderTargetHandle newRenderTarget(const RenderTargetDesc& initInf);
 
 	/// Import a buffer.
 	BufferHandle importBuffer(const BufferView& buff, BufferUsageBit usage);
@@ -493,7 +493,7 @@ private:
 	};
 
 	StackMemoryPool* m_pool = nullptr;
-	DynamicArray<RenderPassDescriptionBase*, MemoryPoolPtrWrapper<StackMemoryPool>> m_passes{m_pool};
+	DynamicArray<RenderPassBase*, MemoryPoolPtrWrapper<StackMemoryPool>> m_passes{m_pool};
 	DynamicArray<RT, MemoryPoolPtrWrapper<StackMemoryPool>> m_renderTargets{m_pool};
 	DynamicArray<BufferRsrc, MemoryPoolPtrWrapper<StackMemoryPool>> m_buffers{m_pool};
 	DynamicArray<AS, MemoryPoolPtrWrapper<StackMemoryPool>> m_as{m_pool};
@@ -528,7 +528,7 @@ public:
 	static constexpr GrObjectType kClassType = GrObjectType::kRenderGraph;
 
 	/// 1st step.
-	void compileNewGraph(const RenderGraphDescription& descr, StackMemoryPool& pool);
+	void compileNewGraph(const RenderGraphBuilder& descr, StackMemoryPool& pool);
 
 	/// 2nd step. Will call a number of RenderPassWorkCallback that populate command buffers and submit work.
 	void recordAndSubmitCommandBuffers(FencePtr* optionalFence = nullptr);
@@ -589,11 +589,11 @@ private:
 
 	[[nodiscard]] static RenderGraph* newInstance();
 
-	BakeContext* newContext(const RenderGraphDescription& descr, StackMemoryPool& pool);
-	void initRenderPassesAndSetDeps(const RenderGraphDescription& descr);
+	BakeContext* newContext(const RenderGraphBuilder& descr, StackMemoryPool& pool);
+	void initRenderPassesAndSetDeps(const RenderGraphBuilder& descr);
 	void initBatches();
-	void initGraphicsPasses(const RenderGraphDescription& descr);
-	void setBatchBarriers(const RenderGraphDescription& descr);
+	void initGraphicsPasses(const RenderGraphBuilder& descr);
+	void setBatchBarriers(const RenderGraphBuilder& descr);
 	/// Switching from compute to graphics and the opposite in the same queue is not great for some GPUs (nVidia)
 	void minimizeSubchannelSwitches();
 	void sortBatchPasses();
@@ -603,20 +603,20 @@ private:
 	/// Every N number of frames clean unused cached items.
 	void periodicCleanup();
 
-	ANKI_HOT static Bool passADependsOnB(const RenderPassDescriptionBase& a, const RenderPassDescriptionBase& b);
+	ANKI_HOT static Bool passADependsOnB(const RenderPassBase& a, const RenderPassBase& b);
 
 	static Bool passHasUnmetDependencies(const BakeContext& ctx, U32 passIdx);
 
 	void setTextureBarrier(Batch& batch, const RenderPassDependency& consumer);
 
 	template<typename TFunc>
-	static void iterateSurfsOrVolumes(const Texture& tex, const TextureSubresourceDescriptor& subresource, TFunc func);
+	static void iterateSurfsOrVolumes(const Texture& tex, const TextureSubresourceDesc& subresource, TFunc func);
 
-	void getCrntUsage(RenderTargetHandle handle, U32 batchIdx, const TextureSubresourceDescriptor& subresource, TextureUsageBit& usage) const;
+	void getCrntUsage(RenderTargetHandle handle, U32 batchIdx, const TextureSubresourceDesc& subresource, TextureUsageBit& usage) const;
 
 	/// @name Dump the dependency graph into a file.
 	/// @{
-	Error dumpDependencyDotFile(const RenderGraphDescription& descr, const BakeContext& ctx, CString path) const;
+	Error dumpDependencyDotFile(const RenderGraphBuilder& descr, const BakeContext& ctx, CString path) const;
 	static GrString textureUsageToStr(StackMemoryPool& pool, TextureUsageBit usage);
 	static GrString bufferUsageToStr(StackMemoryPool& pool, BufferUsageBit usage);
 	static GrString asUsageToStr(StackMemoryPool& pool, AccelerationStructureUsageBit usage);

AnKi/Gr/RenderGraph.inl.h

@@ -17,8 +17,7 @@ inline void RenderPassWorkContext::getBufferState(BufferHandle handle, Buffer*&
 	m_rgraph->getCachedBuffer(handle, buff, offset, range);
 }
 
-inline void RenderPassWorkContext::getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceDescriptor& subresource,
-														Texture*& tex) const
+inline void RenderPassWorkContext::getRenderTargetState(RenderTargetHandle handle, const TextureSubresourceDesc& subresource, Texture*& tex) const
 {
 	TextureUsageBit usage;
 	m_rgraph->getCrntUsage(handle, m_batchIdx, subresource, usage);
@@ -30,7 +29,7 @@ inline Texture& RenderPassWorkContext::getTexture(RenderTargetHandle handle) con
 	return m_rgraph->getTexture(handle);
 }
 
-inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& dep)
+inline void RenderPassBase::validateDep(const RenderPassDependency& dep)
 {
 	// Validate dep
 	if(dep.m_type == RenderPassDependency::Type::kTexture)
@@ -76,7 +75,7 @@ inline void RenderPassDescriptionBase::validateDep(const RenderPassDependency& d
 }
 
 template<RenderPassDependency::Type kType>
-inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency& dep)
+inline void RenderPassBase::newDependency(const RenderPassDependency& dep)
 {
 	ANKI_ASSERT(kType == dep.m_type);
 	validateDep(dep);
@@ -86,7 +85,7 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 		RenderPassDependency& newDep = *m_rtDeps.emplaceBack(dep);
 
 		// Sanitize a bit
-		const RenderGraphDescription::RT& rt = m_descr->m_renderTargets[dep.m_texture.m_handle.m_idx];
+		const RenderGraphBuilder::RT& rt = m_descr->m_renderTargets[dep.m_texture.m_handle.m_idx];
 		if(newDep.m_texture.m_subresource.m_depthStencilAspect == DepthStencilAspectBit::kNone)
 		{
 			if(rt.m_importedTex.isCreated() && !!rt.m_importedTex->getDepthStencilAspect())
@@ -155,9 +154,9 @@ inline void RenderPassDescriptionBase::newDependency(const RenderPassDependency&
 	}
 }
 
-inline void GraphicsRenderPassDescription::setRenderpassInfo(ConstWeakArray<RenderTargetInfo> colorRts, const RenderTargetInfo* depthStencilRt,
-															 U32 minx, U32 miny, U32 width, U32 height, const RenderTargetHandle* vrsRt,
-															 U8 vrsRtTexelSizeX, U8 vrsRtTexelSizeY)
+inline void GraphicsRenderPass::setRenderpassInfo(ConstWeakArray<GraphicsRenderPassTargetDesc> colorRts,
+												  const GraphicsRenderPassTargetDesc* depthStencilRt, U32 minx, U32 miny, U32 width, U32 height,
+												  const RenderTargetHandle* vrsRt, U8 vrsRtTexelSizeX, U8 vrsRtTexelSizeY)
 {
 	m_colorRtCount = U8(colorRts.getSize());
 	for(U32 i = 0; i < m_colorRtCount; ++i)
@@ -192,31 +191,31 @@ inline void GraphicsRenderPassDescription::setRenderpassInfo(ConstWeakArray<Rend
 	m_rpassRenderArea = {minx, miny, width, height};
 }
 
-inline RenderGraphDescription::~RenderGraphDescription()
+inline RenderGraphBuilder::~RenderGraphBuilder()
 {
-	for(RenderPassDescriptionBase* pass : m_passes)
+	for(RenderPassBase* pass : m_passes)
 	{
 		deleteInstance(*m_pool, pass);
 	}
 }
 
-inline GraphicsRenderPassDescription& RenderGraphDescription::newGraphicsRenderPass(CString name)
+inline GraphicsRenderPass& RenderGraphBuilder::newGraphicsRenderPass(CString name)
 {
-	GraphicsRenderPassDescription* pass = newInstance<GraphicsRenderPassDescription>(*m_pool, this, m_pool);
+	GraphicsRenderPass* pass = newInstance<GraphicsRenderPass>(*m_pool, this, m_pool);
 	pass->setName(name);
 	m_passes.emplaceBack(pass);
 	return *pass;
 }
 
-inline ComputeRenderPassDescription& RenderGraphDescription::newComputeRenderPass(CString name)
+inline NonGraphicsRenderPass& RenderGraphBuilder::newNonGraphicsRenderPass(CString name)
 {
-	ComputeRenderPassDescription* pass = newInstance<ComputeRenderPassDescription>(*m_pool, this, m_pool);
+	NonGraphicsRenderPass* pass = newInstance<NonGraphicsRenderPass>(*m_pool, this, m_pool);
 	pass->setName(name);
 	m_passes.emplaceBack(pass);
 	return *pass;
 }
 
-inline RenderTargetHandle RenderGraphDescription::importRenderTarget(Texture* tex, TextureUsageBit usage)
+inline RenderTargetHandle RenderGraphBuilder::importRenderTarget(Texture* tex, TextureUsageBit usage)
 {
 	for([[maybe_unused]] const RT& rt : m_renderTargets)
 	{
@@ -234,16 +233,16 @@ inline RenderTargetHandle RenderGraphDescription::importRenderTarget(Texture* te
 	return out;
 }
 
-inline RenderTargetHandle RenderGraphDescription::importRenderTarget(Texture* tex)
+inline RenderTargetHandle RenderGraphBuilder::importRenderTarget(Texture* tex)
 {
 	RenderTargetHandle out = importRenderTarget(tex, TextureUsageBit::kNone);
 	m_renderTargets.getBack().m_importedAndUndefinedUsage = true;
 	return out;
 }
 
-inline RenderTargetHandle RenderGraphDescription::newRenderTarget(const RenderTargetDescription& initInf)
+inline RenderTargetHandle RenderGraphBuilder::newRenderTarget(const RenderTargetDesc& initInf)
 {
-	ANKI_ASSERT(initInf.m_hash && "Forgot to call RenderTargetDescription::bake");
+	ANKI_ASSERT(initInf.m_hash && "Forgot to call RenderTargetDesc::bake");
 	ANKI_ASSERT(initInf.m_usage == TextureUsageBit::kNone && "Don't need to supply the usage. Render grap will find it");
 
 	for([[maybe_unused]] auto it : m_renderTargets)
@@ -263,7 +262,7 @@ inline RenderTargetHandle RenderGraphDescription::newRenderTarget(const RenderTa
 	return out;
 }
 
-inline BufferHandle RenderGraphDescription::importBuffer(const BufferView& buff, BufferUsageBit usage)
+inline BufferHandle RenderGraphBuilder::importBuffer(const BufferView& buff, BufferUsageBit usage)
 {
 	ANKI_ASSERT(buff.isValid());
 
@@ -284,7 +283,7 @@ inline BufferHandle RenderGraphDescription::importBuffer(const BufferView& buff,
 	return out;
 }
 
-inline AccelerationStructureHandle RenderGraphDescription::importAccelerationStructure(AccelerationStructure* as, AccelerationStructureUsageBit usage)
+inline AccelerationStructureHandle RenderGraphBuilder::importAccelerationStructure(AccelerationStructure* as, AccelerationStructureUsageBit usage)
 {
 	for([[maybe_unused]] const AS& a : m_as)
 	{

AnKi/Gr/Texture.h

@@ -10,7 +10,7 @@
 namespace anki {
 
 // Forward
-class TextureSubresourceDescriptor;
+class TextureSubresourceDesc;
 
 /// @addtogroup graphics
 /// @{
@@ -160,7 +160,7 @@ public:
 
 	/// Returns an index to be used for bindless access. Only for sampling.
 	/// @note It's thread-safe
-	U32 getOrCreateBindlessTextureIndex(const TextureSubresourceDescriptor& subresource);
+	U32 getOrCreateBindlessTextureIndex(const TextureSubresourceDesc& subresource);
 
 protected:
 	U32 m_width = 0;
@@ -190,7 +190,7 @@ private:
 };
 
 /// Defines a part of a texture. This part can be a single surface or volume or the whole texture.
-class TextureSubresourceDescriptor
+class TextureSubresourceDesc
 {
 public:
 	U32 m_mipmap : 5 = 0;
@@ -204,38 +204,38 @@ public:
 
 	U8 _m_padding[2] = {0, 0};
 
-	constexpr TextureSubresourceDescriptor(const TextureSubresourceDescriptor&) = default;
+	constexpr TextureSubresourceDesc(const TextureSubresourceDesc&) = default;
 
-	constexpr TextureSubresourceDescriptor& operator=(const TextureSubresourceDescriptor&) = default;
+	constexpr TextureSubresourceDesc& operator=(const TextureSubresourceDesc&) = default;
 
-	constexpr Bool operator==(const TextureSubresourceDescriptor& b) const
+	constexpr Bool operator==(const TextureSubresourceDesc& b) const
 	{
 		return m_mipmap == b.m_mipmap && m_face == b.m_face && m_layer == b.m_layer && m_allSurfacesOrVolumes == b.m_allSurfacesOrVolumes
 			   && m_depthStencilAspect == b.m_depthStencilAspect;
 	}
 
-	static constexpr TextureSubresourceDescriptor all(DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
+	static constexpr TextureSubresourceDesc all(DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 	{
-		return TextureSubresourceDescriptor(0, 0, 0, true, aspect);
+		return TextureSubresourceDesc(0, 0, 0, true, aspect);
 	}
 
-	static constexpr TextureSubresourceDescriptor surface(U32 mip, U32 face, U32 layer, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
+	static constexpr TextureSubresourceDesc surface(U32 mip, U32 face, U32 layer, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 	{
-		return TextureSubresourceDescriptor(mip, face, layer, false, aspect);
+		return TextureSubresourceDesc(mip, face, layer, false, aspect);
 	}
 
-	static constexpr TextureSubresourceDescriptor firstSurface(DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
+	static constexpr TextureSubresourceDesc firstSurface(DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 	{
-		return TextureSubresourceDescriptor(0, 0, 0, false, aspect);
+		return TextureSubresourceDesc(0, 0, 0, false, aspect);
 	}
 
-	static constexpr TextureSubresourceDescriptor volume(U32 mip)
+	static constexpr TextureSubresourceDesc volume(U32 mip)
 	{
-		return TextureSubresourceDescriptor(mip, 0, 0, false, DepthStencilAspectBit::kNone);
+		return TextureSubresourceDesc(mip, 0, 0, false, DepthStencilAspectBit::kNone);
 	}
 
 	/// Returns true if there is a surface or volume that overlaps. It doesn't check the aspect.
-	Bool overlapsWith(const TextureSubresourceDescriptor& b) const
+	Bool overlapsWith(const TextureSubresourceDesc& b) const
 	{
 		return m_allSurfacesOrVolumes || b.m_allSurfacesOrVolumes || (m_mipmap == b.m_mipmap && m_face == b.m_face && m_layer == b.m_layer);
 	}
@@ -273,14 +273,14 @@ public:
 	}
 
 private:
-	constexpr TextureSubresourceDescriptor(U32 mip, U32 face, U32 layer, Bool allSurfs, DepthStencilAspectBit aspect)
+	constexpr TextureSubresourceDesc(U32 mip, U32 face, U32 layer, Bool allSurfs, DepthStencilAspectBit aspect)
 		: m_mipmap(mip & ((1u << 5u) - 1u))
 		, m_face(face & ((1u << 3u) - 1u))
 		, m_layer(layer & ((1u << 24u) - 1u))
 		, m_allSurfacesOrVolumes(allSurfs)
 		, m_depthStencilAspect(aspect)
 	{
-		static_assert(sizeof(TextureSubresourceDescriptor) == 8, "Because it may get hashed");
+		static_assert(sizeof(TextureSubresourceDesc) == 8, "Because it may get hashed");
 	}
 };
 
@@ -289,11 +289,11 @@ class TextureView
 {
 public:
 	TextureView()
-		: m_subresource(TextureSubresourceDescriptor::all())
+		: m_subresource(TextureSubresourceDesc::all())
 	{
 	}
 
-	explicit TextureView(const Texture* tex, const TextureSubresourceDescriptor& subresource)
+	explicit TextureView(const Texture* tex, const TextureSubresourceDesc& subresource)
 		: m_tex(tex)
 		, m_subresource(subresource)
 	{
@@ -421,7 +421,7 @@ public:
 		return m_subresource.overlapsWith(b.m_subresource);
 	}
 
-	const TextureSubresourceDescriptor& getSubresource() const
+	const TextureSubresourceDesc& getSubresource() const
 	{
 		validate();
 		return m_subresource;
@@ -429,7 +429,7 @@ public:
 
 private:
 	const Texture* m_tex = nullptr;
-	TextureSubresourceDescriptor m_subresource;
+	TextureSubresourceDesc m_subresource;
 
 	void validate() const
 	{

AnKi/Gr/Vulkan/VkTexture.cpp

@@ -21,7 +21,7 @@ Texture* Texture::newInstance(const TextureInitInfo& init)
 	return impl;
 }
 
-U32 Texture::getOrCreateBindlessTextureIndex(const TextureSubresourceDescriptor& subresource)
+U32 Texture::getOrCreateBindlessTextureIndex(const TextureSubresourceDesc& subresource)
 {
 	ANKI_VK_SELF(TextureImpl);
 
@@ -403,7 +403,7 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, VkPipelineStageFlags
 	}
 }
 
-VkImageMemoryBarrier TextureImpl::computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDescriptor& subresource,
+VkImageMemoryBarrier TextureImpl::computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDesc& subresource,
 													 VkPipelineStageFlags& srcStages, VkPipelineStageFlags& dstStages) const
 {
 	ANKI_ASSERT(usageValid(before));
@@ -598,7 +598,7 @@ Error TextureImpl::initViews()
 	return Error::kNone;
 }
 
-const TextureImpl::TextureViewEntry& TextureImpl::getTextureViewEntry(const TextureSubresourceDescriptor& subresource) const
+const TextureImpl::TextureViewEntry& TextureImpl::getTextureViewEntry(const TextureSubresourceDesc& subresource) const
 {
 	const TextureView view(this, subresource);
 

AnKi/Gr/Vulkan/VkTexture.h

@@ -60,13 +60,13 @@ public:
 	}
 
 	/// By knowing the previous and new texture usage calculate the relavant info for a ppline barrier.
-	VkImageMemoryBarrier computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDescriptor& subresource,
+	VkImageMemoryBarrier computeBarrierInfo(TextureUsageBit before, TextureUsageBit after, const TextureSubresourceDesc& subresource,
 											VkPipelineStageFlags& srcStages, VkPipelineStageFlags& dstStages) const;
 
 	/// Predict the image layout.
 	VkImageLayout computeLayout(TextureUsageBit usage) const;
 
-	VkImageSubresourceRange computeVkImageSubresourceRange(const TextureSubresourceDescriptor& subresource) const
+	VkImageSubresourceRange computeVkImageSubresourceRange(const TextureSubresourceDesc& subresource) const
 	{
 		const TextureView in(this, subresource);
 		VkImageSubresourceRange range = {};
@@ -80,7 +80,7 @@ public:
 		return range;
 	}
 
-	VkImageView getImageView(const TextureSubresourceDescriptor& subresource) const
+	VkImageView getImageView(const TextureSubresourceDesc& subresource) const
 	{
 		return getTextureViewEntry(subresource).m_handle;
 	}
@@ -133,7 +133,7 @@ private:
 		return layer * faceCount * m_mipCount + face * m_mipCount + mip;
 	}
 
-	const TextureViewEntry& getTextureViewEntry(const TextureSubresourceDescriptor& subresource) const;
+	const TextureViewEntry& getTextureViewEntry(const TextureSubresourceDesc& subresource) const;
 };
 /// @}
 

AnKi/Renderer/AccelerationStructureBuilder.cpp

@@ -49,13 +49,13 @@ void AccelerationStructureBuilder::populateRenderGraph(RenderingContext& ctx)
 
 	// Build the AS
 	{
-		RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+		RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 		const BufferView scratchBuff = GpuVisibleTransientMemoryPool::getSingleton().allocate(m_runCtx.m_tlas->getBuildScratchBufferSize());
 
 		m_runCtx.m_tlasHandle = rgraph.importAccelerationStructure(m_runCtx.m_tlas.get(), AccelerationStructureUsageBit::kNone);
 
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Build TLAS");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Build TLAS");
 		rpass.newAccelerationStructureDependency(m_runCtx.m_tlasHandle, AccelerationStructureUsageBit::kBuild);
 		rpass.newBufferDependency(visOut.m_someBufferHandle, BufferUsageBit::kAccelerationStructureBuild);
 

AnKi/Renderer/Bloom.cpp

@@ -71,7 +71,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(Bloom);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	const Bool preferCompute = g_preferComputeCVar.get();
 
 	// Main pass
@@ -80,13 +80,13 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		m_runCtx.m_exposureRt = rgraph.newRenderTarget(m_exposure.m_rtDescr);
 
 		// Set the render pass
-		const TextureSubresourceDescriptor inputTexSubresource =
-			TextureSubresourceDescriptor::surface(getRenderer().getDownscaleBlur().getMipmapCount() - 1, 0, 0);
+		const TextureSubresourceDesc inputTexSubresource =
+			TextureSubresourceDesc::surface(getRenderer().getDownscaleBlur().getMipmapCount() - 1, 0, 0);
 
-		RenderPassDescriptionBase* prpass;
+		RenderPassBase* prpass;
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Main");
+			NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Bloom Main");
 
 			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource);
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kStorageComputeWrite);
@@ -95,8 +95,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
-			rpass.setRenderpassInfo({RenderTargetInfo(m_runCtx.m_exposureRt)});
+			GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
+			rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_exposureRt)});
 
 			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment, inputTexSubresource);
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kFramebufferWrite);
@@ -109,8 +109,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_exposure.m_grProg.get());
 
-			const TextureSubresourceDescriptor inputTexSubresource =
-				TextureSubresourceDescriptor::surface(getRenderer().getDownscaleBlur().getMipmapCount() - 1, 0, 0);
+			const TextureSubresourceDesc inputTexSubresource =
+				TextureSubresourceDesc::surface(getRenderer().getDownscaleBlur().getMipmapCount() - 1, 0, 0);
 
 			cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(ANKI_REG(t0), getRenderer().getDownscaleBlur().getRt(), inputTexSubresource);
@@ -141,10 +141,10 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		m_runCtx.m_upscaleRt = rgraph.newRenderTarget(m_upscale.m_rtDescr);
 
 		// Set the render pass
-		RenderPassDescriptionBase* prpass;
+		RenderPassBase* prpass;
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Upscale");
+			NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Bloom Upscale");
 
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledCompute);
 			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kStorageComputeWrite);
@@ -153,8 +153,8 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Upscale");
-			rpass.setRenderpassInfo({RenderTargetInfo(m_runCtx.m_upscaleRt)});
+			GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("Bloom Upscale");
+			rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_upscaleRt)});
 
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSampledFragment);
 			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kFramebufferWrite);
@@ -169,7 +169,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(ANKI_REG(t0), m_runCtx.m_exposureRt);
-			cmdb.bindTexture(ANKI_REG(t1), TextureView(&m_upscale.m_lensDirtImage->getTexture(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG(t1), TextureView(&m_upscale.m_lensDirtImage->getTexture(), TextureSubresourceDesc::all()));
 
 			if(g_preferComputeCVar.get())
 			{

AnKi/Renderer/Bloom.h

@@ -52,7 +52,7 @@ private:
 		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 
-		RenderTargetDescription m_rtDescr;
+		RenderTargetDesc m_rtDescr;
 	} m_exposure;
 
 	class
@@ -62,7 +62,7 @@ private:
 		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 
-		RenderTargetDescription m_rtDescr;
+		RenderTargetDesc m_rtDescr;
 	} m_upscale;
 
 	class

AnKi/Renderer/ClusterBinning.cpp

@@ -47,7 +47,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(ClusterBinning);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Allocate the clusters buffer
 	{
@@ -66,7 +66,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		indirectArgsHandle = rgraph.importBuffer(indirectArgsBuff, BufferUsageBit::kNone);
 
 		// Create the pass
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Cluster binning setup");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Cluster binning setup");
 
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
@@ -102,7 +102,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	// Cluster binning
 	{
 		// Create the pass
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Cluster binning");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Cluster binning");
 
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
 		rpass.newBufferDependency(m_runCtx.m_clustersHandle, BufferUsageBit::kStorageComputeWrite);
@@ -208,7 +208,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 		}
 
 		// Create the pass
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Cluster object packing");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Cluster object packing");
 		rpass.newBufferDependency(indirectArgsHandle, BufferUsageBit::kIndirectCompute);
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{

AnKi/Renderer/Common.h

@@ -74,7 +74,7 @@ inline constexpr Array<Format, kGBufferColorRenderTargetCount> kGBufferColorRend
 class RenderingContext
 {
 public:
-	RenderGraphDescription m_renderGraphDescr;
+	RenderGraphBuilder m_renderGraphDescr;
 
 	CommonMatrices m_matrices;
 	CommonMatrices m_prevMatrices;

AnKi/Renderer/Dbg.cpp

@@ -139,8 +139,8 @@ void Dbg::drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount,
 	cmdb.bindStorageBuffer(ANKI_REG(t2), getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type));
 
 	cmdb.bindSampler(ANKI_REG(s1), getRenderer().getSamplers().m_trilinearRepeat.get());
-	cmdb.bindTexture(ANKI_REG(t3), TextureView(&image.getTexture(), TextureSubresourceDescriptor::all()));
-	cmdb.bindTexture(ANKI_REG(t4), TextureView(&m_spotLightImage->getTexture(), TextureSubresourceDescriptor::all()));
+	cmdb.bindTexture(ANKI_REG(t3), TextureView(&image.getTexture(), TextureSubresourceDesc::all()));
+	cmdb.bindTexture(ANKI_REG(t4), TextureView(&m_spotLightImage->getTexture(), TextureSubresourceDesc::all()));
 
 	cmdb.draw(PrimitiveTopology::kTriangles, 6, objCount);
 }
@@ -236,21 +236,21 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 		return;
 	}
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Create RT
 	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDescr);
 
 	// Create pass
-	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("Debug");
+	GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("Debug");
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 		run(rgraphCtx, ctx);
 	});
 
-	RenderTargetInfo colorRti(m_runCtx.m_rt);
+	GraphicsRenderPassTargetDesc colorRti(m_runCtx.m_rt);
 	colorRti.m_loadOperation = RenderTargetLoadOperation::kClear;
-	RenderTargetInfo depthRti(getRenderer().getGBuffer().getDepthRt());
+	GraphicsRenderPassTargetDesc depthRti(getRenderer().getGBuffer().getDepthRt());
 	depthRti.m_loadOperation = RenderTargetLoadOperation::kLoad;
 	pass.setRenderpassInfo({colorRti}, &depthRti);
 

AnKi/Renderer/Dbg.h

@@ -66,7 +66,7 @@ public:
 	}
 
 private:
-	RenderTargetDescription m_rtDescr;
+	RenderTargetDesc m_rtDescr;
 
 	ImageResourcePtr m_giProbeImage;
 	ImageResourcePtr m_pointLightImage;

AnKi/Renderer/DepthDownscale.cpp

@@ -94,7 +94,7 @@ Error DepthDownscale::init()
 void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(DepthDownscale);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDescr);
 
@@ -102,7 +102,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 	{
 		// Do it with compute
 
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Depth downscale");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Depth downscale");
 
 		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
 
@@ -128,7 +128,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 			for(U32 mip = 0; mip < kMaxMipsSinglePassDownsamplerCanProduce; ++mip)
 			{
-				TextureSubresourceDescriptor surface = TextureSubresourceDescriptor::firstSurface();
+				TextureSubresourceDesc surface = TextureSubresourceDesc::firstSurface();
 				if(mip < m_mipCount)
 				{
 					surface.m_mipmap = mip;
@@ -156,9 +156,9 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 		for(U32 mip = 0; mip < m_mipCount; ++mip)
 		{
 			static constexpr Array<CString, 4> passNames = {"Depth downscale #1", "Depth downscale #2", "Depth downscale #3", "Depth downscale #4"};
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(passNames[mip]);
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(passNames[mip]);
 
-			RenderTargetInfo rti(m_runCtx.m_rt);
+			GraphicsRenderPassTargetDesc rti(m_runCtx.m_rt);
 			rti.m_subresource.m_mipmap = mip;
 			pass.setRenderpassInfo({rti});
 
@@ -168,10 +168,10 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, TextureSubresourceDescriptor::surface(mip - 1, 0, 0));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(mip - 1, 0, 0));
 			}
 
-			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, TextureSubresourceDescriptor::surface(mip, 0, 0));
+			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(mip, 0, 0));
 
 			pass.setWork([this, mip](RenderPassWorkContext& rgraphCtx) {
 				CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -185,7 +185,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 				}
 				else
 				{
-					rgraphCtx.bindTexture(ANKI_REG(t0), m_runCtx.m_rt, TextureSubresourceDescriptor::surface(mip - 1, 0, 0));
+					rgraphCtx.bindTexture(ANKI_REG(t0), m_runCtx.m_rt, TextureSubresourceDesc::surface(mip - 1, 0, 0));
 				}
 
 				const UVec2 size = (getRenderer().getInternalResolution() / 2) >> mip;

AnKi/Renderer/DepthDownscale.h

@@ -18,8 +18,8 @@ namespace anki {
 class DepthDownscale : public RendererObject
 {
 public:
-	static constexpr TextureSubresourceDescriptor kQuarterInternalResolution = TextureSubresourceDescriptor::surface(0, 0, 0);
-	static constexpr TextureSubresourceDescriptor kEighthInternalResolution = TextureSubresourceDescriptor::surface(1, 0, 0);
+	static constexpr TextureSubresourceDesc kQuarterInternalResolution = TextureSubresourceDesc::surface(0, 0, 0);
+	static constexpr TextureSubresourceDesc kEighthInternalResolution = TextureSubresourceDesc::surface(1, 0, 0);
 
 	DepthDownscale() = default;
 
@@ -42,7 +42,7 @@ public:
 	}
 
 private:
-	RenderTargetDescription m_rtDescr;
+	RenderTargetDesc m_rtDescr;
 
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;

AnKi/Renderer/DownscaleBlur.cpp

@@ -55,14 +55,14 @@ Error DownscaleBlur::initInternal()
 
 void DownscaleBlur::importRenderTargets(RenderingContext& ctx)
 {
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex.get(), TextureUsageBit::kSampledCompute);
 }
 
 void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(DownscaleBlur);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Create passes
 	static constexpr Array<CString, 8> passNames = {"Down/Blur #0", "Down/Blur #1", "Down/Blur #2", "Down/Blur #3",
@@ -71,16 +71,16 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 
 	for(U32 i = 0; i < m_passCount; ++i)
 	{
-		RenderPassDescriptionBase* ppass;
+		RenderPassBase* ppass;
 		if(g_preferComputeCVar.get())
 		{
-			ppass = &rgraph.newComputeRenderPass(passNames[i]);
+			ppass = &rgraph.newNonGraphicsRenderPass(passNames[i]);
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(passNames[i]);
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(passNames[i]);
 
-			RenderTargetInfo rtInf(m_runCtx.m_rt);
+			GraphicsRenderPassTargetDesc rtInf(m_runCtx.m_rt);
 			rtInf.m_subresource.m_mipmap = i;
 			pass.setRenderpassInfo({rtInf});
 
@@ -92,15 +92,15 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 
 		if(i > 0)
 		{
-			const TextureSubresourceDescriptor sampleSubresource = TextureSubresourceDescriptor::surface(i - 1, 0, 0);
-			const TextureSubresourceDescriptor renderSubresource = TextureSubresourceDescriptor::surface(i, 0, 0);
+			const TextureSubresourceDesc sampleSubresource = TextureSubresourceDesc::surface(i - 1, 0, 0);
+			const TextureSubresourceDesc renderSubresource = TextureSubresourceDesc::surface(i, 0, 0);
 
 			ppass->newTextureDependency(m_runCtx.m_rt, writeUsage, renderSubresource);
 			ppass->newTextureDependency(m_runCtx.m_rt, readUsage, sampleSubresource);
 		}
 		else
 		{
-			ppass->newTextureDependency(m_runCtx.m_rt, writeUsage, TextureSubresourceDescriptor::firstSurface());
+			ppass->newTextureDependency(m_runCtx.m_rt, writeUsage, TextureSubresourceDesc::firstSurface());
 			ppass->newTextureDependency(inRt, readUsage);
 		}
 
@@ -123,7 +123,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 
 	if(passIdx > 0)
 	{
-		rgraphCtx.bindTexture(ANKI_REG(t0), m_runCtx.m_rt, TextureSubresourceDescriptor::surface(passIdx - 1, 0, 0));
+		rgraphCtx.bindTexture(ANKI_REG(t0), m_runCtx.m_rt, TextureSubresourceDesc::surface(passIdx - 1, 0, 0));
 	}
 	else
 	{
@@ -137,7 +137,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 		const Vec4 fbSize(F32(vpWidth), F32(vpHeight), 0.0f, 0.0f);
 		cmdb.setPushConstants(&fbSize, sizeof(fbSize));
 
-		rgraphCtx.bindTexture(ANKI_REG(u1), m_runCtx.m_rt, TextureSubresourceDescriptor::surface(passIdx, 0, 0));
+		rgraphCtx.bindTexture(ANKI_REG(u1), m_runCtx.m_rt, TextureSubresourceDesc::surface(passIdx, 0, 0));
 
 		dispatchPPCompute(cmdb, 8, 8, vpWidth, vpHeight);
 	}

AnKi/Renderer/FinalComposite.cpp

@@ -68,15 +68,15 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(RFinalComposite);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Create the pass
-	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("Final Composite");
+	GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("Final Composite");
 
 	pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 		run(rgraphCtx);
 	});
-	pass.setRenderpassInfo({RenderTargetInfo(ctx.m_outRenderTarget)});
+	pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(ctx.m_outRenderTarget)});
 
 	pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kFramebufferWrite);
 
@@ -140,7 +140,7 @@ void FinalComposite::run(RenderPassWorkContext& rgraphCtx)
 		rgraphCtx.bindTexture(ANKI_REG(t0), getRenderer().getScale().getTonemappedRt());
 
 		rgraphCtx.bindTexture(ANKI_REG(t1), getRenderer().getBloom().getRt());
-		cmdb.bindTexture(ANKI_REG(t2), TextureView(&m_lut->getTexture(), TextureSubresourceDescriptor::all()));
+		cmdb.bindTexture(ANKI_REG(t2), TextureView(&m_lut->getTexture(), TextureSubresourceDesc::all()));
 		rgraphCtx.bindTexture(ANKI_REG(t3), getRenderer().getMotionVectors().getMotionVectorsRt());
 		rgraphCtx.bindTexture(ANKI_REG(t4), getRenderer().getGBuffer().getDepthRt());
 

AnKi/Renderer/ForwardShading.cpp

@@ -25,7 +25,7 @@ namespace anki {
 void ForwardShading::populateRenderGraph(RenderingContext& ctx)
 {
 	m_runCtx = {};
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	const Array<F32, kMaxLodCount - 1> lodDistances = {g_lod0MaxDistanceCVar.get(), g_lod1MaxDistanceCVar.get()};
 
@@ -117,7 +117,7 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 	getRenderer().getLensFlare().runDrawFlares(ctx, cmdb);
 }
 
-void ForwardShading::setDependencies(GraphicsRenderPassDescription& pass)
+void ForwardShading::setDependencies(GraphicsRenderPass& pass)
 {
 	pass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledFragment,
 							  DepthDownscale::kQuarterInternalResolution);

AnKi/Renderer/ForwardShading.h

@@ -28,7 +28,7 @@ public:
 
 	void populateRenderGraph(RenderingContext& ctx);
 
-	void setDependencies(GraphicsRenderPassDescription& pass);
+	void setDependencies(GraphicsRenderPass& pass);
 
 	void run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx);
 

AnKi/Renderer/GBuffer.cpp

@@ -79,7 +79,7 @@ Error GBuffer::initInternal()
 
 void GBuffer::importRenderTargets(RenderingContext& ctx)
 {
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	if(m_runCtx.m_crntFrameDepthRt.isValid()) [[likely]]
 	{
@@ -103,7 +103,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(GBuffer);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Visibility
 	GpuVisibilityOutput visOut;
@@ -161,9 +161,9 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	}
 
 	// Create pass
-	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("GBuffer");
+	GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("GBuffer");
 
-	Array<RenderTargetInfo, kGBufferColorRenderTargetCount> colorRti;
+	Array<GraphicsRenderPassTargetDesc, kGBufferColorRenderTargetCount> colorRti;
 	colorRti[0].m_handle = rts[0];
 	colorRti[0].m_loadOperation = RenderTargetLoadOperation::kClear;
 	colorRti[1].m_handle = rts[1];
@@ -173,7 +173,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	colorRti[3].m_handle = rts[3];
 	colorRti[3].m_loadOperation = RenderTargetLoadOperation::kClear;
 	colorRti[3].m_clearValue.m_colorf = {1.0f, 1.0f, 1.0f, 1.0f};
-	RenderTargetInfo depthRti(m_runCtx.m_crntFrameDepthRt);
+	GraphicsRenderPassTargetDesc depthRti(m_runCtx.m_crntFrameDepthRt);
 	depthRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 	depthRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
 	depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
@@ -208,7 +208,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 
 		if(GrManager::getSingleton().getDeviceCapabilities().m_meshShaders)
 		{
-			const TextureSubresourceDescriptor subresource = TextureSubresourceDescriptor::all();
+			const TextureSubresourceDesc subresource = TextureSubresourceDesc::all();
 			Texture* tex;
 			rgraphCtx.getRenderTargetState(m_runCtx.m_hzbRt, subresource, tex);
 			args.m_hzbTexture = TextureView(tex, subresource);

AnKi/Renderer/GBuffer.h

@@ -68,7 +68,7 @@ public:
 	}
 
 private:
-	Array<RenderTargetDescription, kGBufferColorRenderTargetCount> m_colorRtDescrs;
+	Array<RenderTargetDesc, kGBufferColorRenderTargetCount> m_colorRtDescrs;
 	Array<TexturePtr, 2> m_depthRts;
 	TexturePtr m_hzbRt;
 

AnKi/Renderer/GBufferPost.cpp

@@ -41,10 +41,10 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 		return;
 	}
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Create pass
-	GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("GBuffPost");
+	GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("GBuffPost");
 
 	rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
@@ -74,9 +74,9 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 		cmdb.setBlendFactors(1, BlendFactor::kOne, BlendFactor::kZero);
 	});
 
-	RenderTargetInfo rt0(getRenderer().getGBuffer().getColorRt(0));
+	GraphicsRenderPassTargetDesc rt0(getRenderer().getGBuffer().getColorRt(0));
 	rt0.m_loadOperation = RenderTargetLoadOperation::kLoad;
-	RenderTargetInfo rt1(getRenderer().getGBuffer().getColorRt(1));
+	GraphicsRenderPassTargetDesc rt1(getRenderer().getGBuffer().getColorRt(1));
 	rt1.m_loadOperation = RenderTargetLoadOperation::kLoad;
 	rpass.setRenderpassInfo({rt0, rt1});
 

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -69,7 +69,7 @@ Error IndirectDiffuseProbes::initGBuffer()
 {
 	// Create RT descriptions
 	{
-		RenderTargetDescription texinit =
+		RenderTargetDesc texinit =
 			getRenderer().create2DRenderTargetDescription(m_tileSize, m_tileSize, kGBufferColorRenderTargetFormats[0], "GI GBuffer");
 		texinit.m_type = TextureType::kCube;
 
@@ -169,7 +169,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 		g_giProbeRenderCountStatVar.increment(1);
 	}
 
-	RenderGraphDescription& rgraph = rctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = rctx.m_renderGraphDescr;
 
 	// Create some common resources to save on memory
 	Array<RenderTargetHandle, kMaxColorRenderTargets> gbufferColorRts;
@@ -235,16 +235,16 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 			// GBuffer
 			{
-				GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("GI: GBuffer cell:%u face:%u", cellIdx, f));
+				GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(generateTempPassName("GI: GBuffer cell:%u face:%u", cellIdx, f));
 
-				Array<RenderTargetInfo, kGBufferColorRenderTargetCount> colorRtis;
+				Array<GraphicsRenderPassTargetDesc, kGBufferColorRenderTargetCount> colorRtis;
 				for(U j = 0; j < kGBufferColorRenderTargetCount; ++j)
 				{
 					colorRtis[j].m_loadOperation = RenderTargetLoadOperation::kClear;
 					colorRtis[j].m_subresource.m_face = f;
 					colorRtis[j].m_handle = gbufferColorRts[j];
 				}
-				RenderTargetInfo depthRti(gbufferDepthRt);
+				GraphicsRenderPassTargetDesc depthRti(gbufferDepthRt);
 				depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 				depthRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 				depthRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
@@ -253,10 +253,10 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSubresourceDescriptor::surface(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
 				}
 				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllFramebuffer,
-										  TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
+										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 
 				pass.newBufferDependency((meshletVisOut.isFilled()) ? meshletVisOut.m_dependency : visOut.m_dependency,
 										 BufferUsageBit::kIndirectDraw);
@@ -335,16 +335,16 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 			if(doShadows)
 			{
 				// Create the pass
-				GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("GI: Shadows cell:%u face:%u", cellIdx, f));
+				GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(generateTempPassName("GI: Shadows cell:%u face:%u", cellIdx, f));
 
-				RenderTargetInfo depthRti(shadowsRt);
+				GraphicsRenderPassTargetDesc depthRti(shadowsRt);
 				depthRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 				depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 				depthRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
 				pass.setRenderpassInfo({}, &depthRti);
 
 				pass.newTextureDependency(shadowsRt, TextureUsageBit::kAllFramebuffer,
-										  TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
+										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 				pass.newBufferDependency((shadowMeshletVisOut.isFilled()) ? shadowMeshletVisOut.m_dependency : shadowVisOut.m_dependency,
 										 BufferUsageBit::kIndirectDraw);
 
@@ -391,24 +391,23 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 			// Light shading pass
 			{
-				GraphicsRenderPassDescription& pass =
-					rgraph.newGraphicsRenderPass(generateTempPassName("GI: Light shading cell:%u face:%u", cellIdx, f));
+				GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(generateTempPassName("GI: Light shading cell:%u face:%u", cellIdx, f));
 
-				RenderTargetInfo colorRti(lightShadingRt);
+				GraphicsRenderPassTargetDesc colorRti(lightShadingRt);
 				colorRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 				colorRti.m_subresource.m_face = f;
 				pass.setRenderpassInfo({colorRti});
 
 				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
 
-				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite, TextureSubresourceDescriptor::surface(0, f, 0));
+				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSubresourceDescriptor::surface(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(0, f, 0));
 				}
 				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSampledFragment,
-										  TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
+										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 
 				if(shadowsRt.isValid())
 				{
@@ -472,7 +471,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 		// Irradiance pass. First & 2nd bounce
 		{
-			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("GI: Irradiance cell:%u", cellIdx));
+			NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GI: Irradiance cell:%u", cellIdx));
 
 			pass.newTextureDependency(lightShadingRt, TextureUsageBit::kSampledCompute);
 			pass.newTextureDependency(irradianceVolume, TextureUsageBit::kStorageComputeWrite);

AnKi/Renderer/IndirectDiffuseProbes.h

@@ -40,20 +40,20 @@ private:
 	class
 	{
 	public:
-		Array<RenderTargetDescription, kGBufferColorRenderTargetCount> m_colorRtDescrs;
-		RenderTargetDescription m_depthRtDescr;
+		Array<RenderTargetDesc, kGBufferColorRenderTargetCount> m_colorRtDescrs;
+		RenderTargetDesc m_depthRtDescr;
 	} m_gbuffer; ///< G-buffer pass.
 
 	class
 	{
 	public:
-		RenderTargetDescription m_rtDescr;
+		RenderTargetDesc m_rtDescr;
 	} m_shadowMapping;
 
 	class LS
 	{
 	public:
-		RenderTargetDescription m_rtDescr;
+		RenderTargetDesc m_rtDescr;
 		TraditionalDeferredLightShading m_deferred;
 	} m_lightShading; ///< Light shading.
 

AnKi/Renderer/LensFlare.cpp

@@ -51,14 +51,14 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 		return;
 	}
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Create indirect buffer
 	m_runCtx.m_indirectBuff = GpuVisibleTransientMemoryPool::getSingleton().allocate(sizeof(DrawIndirectArgs) * flareCount);
 	m_runCtx.m_indirectBuffHandle = rgraph.importBuffer(m_runCtx.m_indirectBuff, BufferUsageBit::kNone);
 
 	// Create the pass
-	ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Lens flare indirect");
+	NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("Lens flare indirect");
 
 	rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite);
 	rpass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledCompute,
@@ -139,7 +139,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBuffer& cmdb)
 
 		// Render
 		cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearRepeat.get());
-		cmdb.bindTexture(ANKI_REG(t1), TextureView(&comp.getImage().getTexture(), TextureSubresourceDescriptor::all()));
+		cmdb.bindTexture(ANKI_REG(t1), TextureView(&comp.getImage().getTexture(), TextureSubresourceDesc::all()));
 
 		cmdb.drawIndirect(PrimitiveTopology::kTriangleStrip, BufferView(m_runCtx.m_indirectBuff).incrementOffset(count * sizeof(DrawIndirectArgs)));
 

AnKi/Renderer/LightShading.cpp

@@ -126,7 +126,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		rgraphCtx.bindTexture(ANKI_REG(t9), getRenderer().getShadowmapsResolve().getRt());
 		rgraphCtx.bindTexture(ANKI_REG(t10), getRenderer().getSsao().getRt());
 		rgraphCtx.bindTexture(ANKI_REG(t11), getRenderer().getSsr().getRt());
-		cmdb.bindTexture(ANKI_REG(t12), TextureView(&getRenderer().getProbeReflections().getIntegrationLut(), TextureSubresourceDescriptor::all()));
+		cmdb.bindTexture(ANKI_REG(t12), TextureView(&getRenderer().getProbeReflections().getIntegrationLut(), TextureSubresourceDesc::all()));
 
 		// Draw
 		drawQuad(cmdb);
@@ -176,7 +176,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 			cmdb.setPushConstants(&pc, sizeof(pc));
 
 			cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias.get());
-			cmdb.bindTexture(ANKI_REG(t0), TextureView(&sky->getImageResource().getTexture(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG(t0), TextureView(&sky->getImageResource().getTexture(), TextureSubresourceDesc::all()));
 		}
 		else
 		{
@@ -248,7 +248,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 void LightShading::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(LightShading);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	const Bool enableVrs = GrManager::getSingleton().getDeviceCapabilities().m_vrs && g_vrsCVar.get();
 
@@ -262,14 +262,14 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 	}
 
 	// Create pass
-	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("Light&FW Shad");
+	GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("Light&FW Shad");
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 		run(ctx, rgraphCtx);
 	});
 
-	RenderTargetInfo colorRt(m_runCtx.m_rt);
-	RenderTargetInfo depthRt(getRenderer().getGBuffer().getDepthRt());
+	GraphicsRenderPassTargetDesc colorRt(m_runCtx.m_rt);
+	GraphicsRenderPassTargetDesc depthRt(getRenderer().getGBuffer().getDepthRt());
 	depthRt.m_loadOperation = RenderTargetLoadOperation::kLoad;
 	depthRt.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 	pass.setRenderpassInfo({colorRt}, &depthRt, 0, 0, kMaxU32, kMaxU32, (enableVrs) ? &sriRt : nullptr,

AnKi/Renderer/LightShading.h

@@ -35,7 +35,7 @@ private:
 	class
 	{
 	public:
-		RenderTargetDescription m_rtDescr;
+		RenderTargetDesc m_rtDescr;
 
 		// Light shaders
 		ShaderProgramResourcePtr m_prog;

AnKi/Renderer/MainRenderer.cpp

@@ -110,9 +110,9 @@ Error MainRenderer::render(Texture* presentTex)
 	// Blit renderer's result to default FB if needed
 	if(!m_rDrawToDefaultFb)
 	{
-		GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Final Blit");
+		GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Final Blit");
 
-		pass.setRenderpassInfo({RenderTargetInfo(presentRt)});
+		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(presentRt)});
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 			cmdb.setViewport(0, 0, m_swapchainResolution.x(), m_swapchainResolution.y());
@@ -130,7 +130,7 @@ Error MainRenderer::render(Texture* presentTex)
 
 	// Create a dummy pass to transition the presentable image to present
 	{
-		ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Present");
+		NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Present");
 
 		pass.setWork([]([[maybe_unused]] RenderPassWorkContext& rgraphCtx) {
 			// Do nothing. This pass is dummy

AnKi/Renderer/MainRenderer.h

@@ -60,7 +60,7 @@ private:
 	UVec2 m_swapchainResolution = UVec2(0u);
 
 	RenderGraphPtr m_rgraph;
-	RenderTargetDescription m_tmpRtDesc;
+	RenderTargetDesc m_tmpRtDesc;
 
 	class
 	{

AnKi/Renderer/MotionVectors.cpp

@@ -40,16 +40,16 @@ Error MotionVectors::initInternal()
 void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(MotionVectors);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	m_runCtx.m_motionVectorsRtHandle = rgraph.newRenderTarget(m_motionVectorsRtDescr);
 
-	RenderPassDescriptionBase* ppass;
+	RenderPassBase* ppass;
 	TextureUsageBit readUsage;
 	TextureUsageBit writeUsage;
 	if(g_preferComputeCVar.get())
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("MotionVectors");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("MotionVectors");
 
 		readUsage = TextureUsageBit::kSampledCompute;
 		writeUsage = TextureUsageBit::kStorageComputeWrite;
@@ -57,8 +57,8 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("MotionVectors");
-		pass.setRenderpassInfo({RenderTargetInfo(m_runCtx.m_motionVectorsRtHandle)});
+		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("MotionVectors");
+		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_motionVectorsRtHandle)});
 
 		readUsage = TextureUsageBit::kSampledFragment;
 		writeUsage = TextureUsageBit::kFramebufferWrite;

AnKi/Renderer/MotionVectors.h

@@ -43,7 +43,7 @@ public:
 private:
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
-	RenderTargetDescription m_motionVectorsRtDescr;
+	RenderTargetDesc m_motionVectorsRtDescr;
 
 	class
 	{

AnKi/Renderer/PrimaryNonRenderableVisibility.cpp

@@ -43,7 +43,7 @@ static WeakArray<TComponent*> gatherComponents(ConstWeakArray<UVec2> pairs, TArr
 void PrimaryNonRenderableVisibility::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(PrimaryNonRenderableVisibility);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	m_runCtx = {};
 

AnKi/Renderer/ProbeReflections.cpp

@@ -70,8 +70,8 @@ Error ProbeReflections::initGBuffer()
 
 	// Create RT descriptions
 	{
-		RenderTargetDescription texinit = getRenderer().create2DRenderTargetDescription(m_gbuffer.m_tileSize, m_gbuffer.m_tileSize,
-																						kGBufferColorRenderTargetFormats[0], "CubeRefl GBuffer");
+		RenderTargetDesc texinit = getRenderer().create2DRenderTargetDescription(m_gbuffer.m_tileSize, m_gbuffer.m_tileSize,
+																				 kGBufferColorRenderTargetFormats[0], "CubeRefl GBuffer");
 
 		// Create color RT descriptions
 		for(U32 i = 0; i < kGBufferColorRenderTargetCount; ++i)
@@ -175,7 +175,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 	g_probeReflectionCountStatVar.increment(1);
 	probeToRefresh->setEnvironmentTextureAsRefreshed();
 
-	RenderGraphDescription& rgraph = rctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = rctx.m_renderGraphDescr;
 
 	const LightComponent* dirLightc = SceneGraph::getSingleton().getDirectionalLight();
 	const Bool doShadows = dirLightc && dirLightc->getShadowEnabled();
@@ -236,16 +236,16 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		// GBuffer pass
 		{
 			// Create pass
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: GBuffer face:%u", f));
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: GBuffer face:%u", f));
 
-			Array<RenderTargetInfo, kGBufferColorRenderTargetCount> colorRtis;
+			Array<GraphicsRenderPassTargetDesc, kGBufferColorRenderTargetCount> colorRtis;
 			for(U j = 0; j < kGBufferColorRenderTargetCount; ++j)
 			{
 				colorRtis[j].m_loadOperation = RenderTargetLoadOperation::kClear;
 				colorRtis[j].m_subresource.m_face = f;
 				colorRtis[j].m_handle = gbufferColorRts[j];
 			}
-			RenderTargetInfo depthRti(gbufferDepthRt);
+			GraphicsRenderPassTargetDesc depthRti(gbufferDepthRt);
 			depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 			depthRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 			depthRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
@@ -254,7 +254,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSubresourceDescriptor::surface(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
 			}
 
 			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllFramebuffer, DepthStencilAspectBit::kDepth);
@@ -332,9 +332,9 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		if(doShadows)
 		{
 			// Pass
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: Shadows face:%u", f));
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: Shadows face:%u", f));
 
-			RenderTargetInfo depthRti(shadowMapRt);
+			GraphicsRenderPassTargetDesc depthRti(shadowMapRt);
 			depthRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 			depthRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
 			depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
@@ -386,19 +386,19 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 		// Light shading pass
 		{
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: light shading face:%u", f));
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: light shading face:%u", f));
 
-			RenderTargetInfo colorRti(probeTexture);
+			GraphicsRenderPassTargetDesc colorRti(probeTexture);
 			colorRti.m_subresource.m_face = f;
 			colorRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 			pass.setRenderpassInfo({colorRti});
 
 			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
-			pass.newTextureDependency(probeTexture, TextureUsageBit::kFramebufferWrite, TextureSubresourceDescriptor::surface(0, f, 0));
+			pass.newTextureDependency(probeTexture, TextureUsageBit::kFramebufferWrite, TextureSubresourceDesc::surface(0, f, 0));
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSubresourceDescriptor::surface(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(0, f, 0));
 			}
 			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSampledFragment, DepthStencilAspectBit::kDepth);
 
@@ -450,7 +450,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 	// Compute Irradiance
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Cube refl: Irradiance");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Cube refl: Irradiance");
 
 		pass.newTextureDependency(probeTexture, TextureUsageBit::kSampledCompute);
 
@@ -475,7 +475,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 	// Append irradiance back to refl cubemap
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Cube refl: Apply indirect");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Cube refl: Apply indirect");
 
 		for(U i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)
 		{
@@ -505,7 +505,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 			for(U8 f = 0; f < 6; ++f)
 			{
-				rgraphCtx.bindTexture(Register(HlslResourceType::kUav, f), probeTexture, TextureSubresourceDescriptor::surface(0, f, 0));
+				rgraphCtx.bindTexture(Register(HlslResourceType::kUav, f), probeTexture, TextureSubresourceDesc::surface(0, f, 0));
 			}
 
 			dispatchPPCompute(cmdb, 8, 8, m_lightShading.m_tileSize, m_lightShading.m_tileSize);

AnKi/Renderer/ProbeReflections.h

@@ -59,8 +59,8 @@ private:
 	{
 	public:
 		U32 m_tileSize = 0;
-		Array<RenderTargetDescription, kGBufferColorRenderTargetCount> m_colorRtDescrs;
-		RenderTargetDescription m_depthRtDescr;
+		Array<RenderTargetDesc, kGBufferColorRenderTargetCount> m_colorRtDescrs;
+		RenderTargetDesc m_depthRtDescr;
 	} m_gbuffer; ///< G-buffer pass.
 
 	class LS
@@ -90,7 +90,7 @@ private:
 	class
 	{
 	public:
-		RenderTargetDescription m_rtDescr;
+		RenderTargetDesc m_rtDescr;
 	} m_shadowMapping;
 
 	class

AnKi/Renderer/Renderer.cpp

@@ -421,9 +421,9 @@ TextureInitInfo Renderer::create2DRenderTargetInitInfo(U32 w, U32 h, Format form
 	return init;
 }
 
-RenderTargetDescription Renderer::create2DRenderTargetDescription(U32 w, U32 h, Format format, CString name)
+RenderTargetDesc Renderer::create2DRenderTargetDescription(U32 w, U32 h, Format format, CString name)
 {
-	RenderTargetDescription init(name);
+	RenderTargetDesc init(name);
 
 	init.m_width = w;
 	init.m_height = h;
@@ -494,11 +494,11 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 							aspect |= DepthStencilAspectBit::kStencil;
 						}
 
-						rt.m_textureView = TextureView(tex.get(), TextureSubresourceDescriptor::surface(mip, face, layer, aspect));
+						rt.m_textureView = TextureView(tex.get(), TextureSubresourceDesc::surface(mip, face, layer, aspect));
 					}
 					else
 					{
-						rt.m_textureView = TextureView(tex.get(), TextureSubresourceDescriptor::surface(mip, face, layer));
+						rt.m_textureView = TextureView(tex.get(), TextureSubresourceDesc::surface(mip, face, layer));
 					}
 
 					TextureBarrierInfo barrier = {rt.m_textureView, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite};
@@ -550,7 +550,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 
 					cmdb->setPushConstants(&clearVal.m_colorf[0], sizeof(clearVal.m_colorf));
 
-					const TextureView view(tex.get(), TextureSubresourceDescriptor::surface(mip, face, layer));
+					const TextureView view(tex.get(), TextureSubresourceDesc::surface(mip, face, layer));
 
 					cmdb->bindTexture(ANKI_REG(u0), view);
 
@@ -672,14 +672,14 @@ Format Renderer::getDepthNoStencilFormat() const
 
 void Renderer::gpuSceneCopy(RenderingContext& ctx)
 {
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	m_runCtx.m_gpuSceneHandle =
 		rgraph.importBuffer(GpuSceneBuffer::getSingleton().getBufferView(), GpuSceneBuffer::getSingleton().getBuffer().getBufferUsage());
 
 	if(GpuSceneMicroPatcher::getSingleton().patchingIsNeeded())
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("GPU scene patching");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("GPU scene patching");
 		rpass.newBufferDependency(m_runCtx.m_gpuSceneHandle, BufferUsageBit::kStorageComputeWrite);
 
 		rpass.setWork([](RenderPassWorkContext& rgraphCtx) {

AnKi/Renderer/Renderer.h

@@ -100,7 +100,7 @@ public:
 	[[nodiscard]] TextureInitInfo create2DRenderTargetInitInfo(U32 w, U32 h, Format format, TextureUsageBit usage, CString name = {});
 
 	/// Create the init info for a 2D texture that will be used as a render target.
-	[[nodiscard]] RenderTargetDescription create2DRenderTargetDescription(U32 w, U32 h, Format format, CString name = {});
+	[[nodiscard]] RenderTargetDesc create2DRenderTargetDescription(U32 w, U32 h, Format format, CString name = {});
 
 	[[nodiscard]] TexturePtr createAndClearRenderTarget(const TextureInitInfo& inf, TextureUsageBit initialUsage,
 														const ClearValue& clearVal = ClearValue());

AnKi/Renderer/RtShadows.cpp

@@ -158,7 +158,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute, \
 		DepthDownscale::kQuarterInternalResolution
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Import RTs
 	{
@@ -211,7 +211,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		sbtBuildIndirectArgsBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate(sizeof(DispatchIndirectArgs));
 		sbtBuildIndirectArgsHandle = rgraph.importBuffer(sbtBuildIndirectArgsBuffer, BufferUsageBit::kStorageComputeWrite);
 
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows setup build SBT");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows setup build SBT");
 
 		rpass.newBufferDependency(sbtBuildIndirectArgsHandle, BufferUsageBit::kAccelerationStructureBuild);
 
@@ -245,7 +245,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		memcpy(sbtMem + m_sbtRecordSize, &shaderGroupHandles[m_missShaderGroupIdx * shaderHandleSize], shaderHandleSize);
 
 		// Create the pass
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows build SBT");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows build SBT");
 
 		BufferHandle visibilityHandle;
 		BufferView visibleRenderableIndicesBuff;
@@ -280,7 +280,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 	// Ray gen
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows");
 
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays);
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kStorageTraceRaysWrite);
@@ -332,13 +332,13 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			cmdb.bindSampler(ANKI_REG2(s1, space2), getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(ANKI_REG2(t1, space2), getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 			rgraphCtx.bindTexture(ANKI_REG2(t2, space2), getRenderer().getMotionVectors().getMotionVectorsRt());
-			cmdb.bindTexture(ANKI_REG2(t3, space2), TextureView(m_dummyHistoryLenTex.get(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG2(t3, space2), TextureView(m_dummyHistoryLenTex.get(), TextureSubresourceDesc::all()));
 			rgraphCtx.bindTexture(ANKI_REG2(t4, space2), getRenderer().getGBuffer().getColorRt(2));
 			rgraphCtx.bindAccelerationStructure(ANKI_REG2(t5, space2),
 												getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle());
 			rgraphCtx.bindTexture(ANKI_REG2(t6, space2), m_runCtx.m_prevMomentsRt);
 			rgraphCtx.bindTexture(ANKI_REG2(u1, space2), m_runCtx.m_currentMomentsRt);
-			cmdb.bindTexture(ANKI_REG2(t7, space2), TextureView(&m_blueNoiseImage->getTexture(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG2(t7, space2), TextureView(&m_blueNoiseImage->getTexture(), TextureSubresourceDesc::all()));
 
 			cmdb.traceRays(sbtBuffer, m_sbtRecordSize, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount(), 1,
 						   getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, 1);
@@ -348,7 +348,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	// Denoise pass horizontal
 	if(!m_useSvgf)
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows Denoise Horizontal");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows Denoise Horizontal");
 
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			runDenoise(ctx, rgraphCtx, true);
@@ -365,7 +365,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	// Denoise pass vertical
 	if(!m_useSvgf)
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows Denoise Vertical");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows Denoise Vertical");
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			runDenoise(ctx, rgraphCtx, false);
 		});
@@ -381,7 +381,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	// Variance calculation pass
 	if(m_useSvgf)
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows SVGF Variance");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows SVGF Variance");
 
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
@@ -401,7 +401,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			rgraphCtx.bindTexture(ANKI_REG(t0), m_runCtx.m_intermediateShadowsRts[0]);
 			rgraphCtx.bindTexture(ANKI_REG(t1), m_runCtx.m_currentMomentsRt);
-			cmdb.bindTexture(ANKI_REG(t2), TextureView(m_dummyHistoryLenTex.get(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG(t2), TextureView(m_dummyHistoryLenTex.get(), TextureSubresourceDesc::all()));
 			rgraphCtx.bindTexture(ANKI_REG(t3), getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 
 			rgraphCtx.bindTexture(ANKI_REG(u0), m_runCtx.m_intermediateShadowsRts[1]);
@@ -422,7 +422,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			const Bool lastPass = i == U32(m_atrousPassCount - 1);
 			const U32 readRtIdx = (i + 1) & 1;
 
-			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows SVGF Atrous");
+			NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows SVGF Atrous");
 
 			rpass.newTextureDependency(ANKI_DEPTH_DEP);
 			rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
@@ -482,7 +482,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 	// Upscale
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("RtShadows Upscale");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("RtShadows Upscale");
 
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
@@ -520,7 +520,7 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 	rgraphCtx.bindTexture(ANKI_REG(t1), getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 	rgraphCtx.bindTexture(ANKI_REG(t2), getRenderer().getGBuffer().getColorRt(2));
 	rgraphCtx.bindTexture(ANKI_REG(t3), m_runCtx.m_currentMomentsRt);
-	cmdb.bindTexture(ANKI_REG(t4), TextureView(m_dummyHistoryLenTex.get(), TextureSubresourceDescriptor::all()));
+	cmdb.bindTexture(ANKI_REG(t4), TextureView(m_dummyHistoryLenTex.get(), TextureSubresourceDesc::all()));
 
 	rgraphCtx.bindTexture(ANKI_REG(u0), (horizontal) ? m_runCtx.m_intermediateShadowsRts[1] : m_runCtx.m_historyRt);
 

AnKi/Renderer/RtShadows.h

@@ -40,12 +40,12 @@ public:
 	/// @name Render targets
 	/// @{
 	TexturePtr m_historyRt;
-	RenderTargetDescription m_intermediateShadowsRtDescr;
-	RenderTargetDescription m_upscaledRtDescr;
+	RenderTargetDesc m_intermediateShadowsRtDescr;
+	RenderTargetDesc m_upscaledRtDescr;
 
 	Array<TexturePtr, 2> m_momentsRts;
 
-	RenderTargetDescription m_varianceRtDescr;
+	RenderTargetDesc m_varianceRtDescr;
 
 	TexturePtr m_dummyHistoryLenTex;
 	/// @}

AnKi/Renderer/Scale.cpp

@@ -155,7 +155,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		return;
 	}
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	const Bool preferCompute = g_preferComputeCVar.get();
 
 	// Step 1: Upscaling
@@ -164,7 +164,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		m_runCtx.m_upscaledHdrRt = rgraph.newRenderTarget(m_upscaleAndSharpenRtDescr);
 		m_runCtx.m_upscaledTonemappedRt = {};
 
-		ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("DLSS");
+		NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("DLSS");
 
 		// DLSS says input textures in sampled state and out as storage image
 		const TextureUsageBit readUsage = TextureUsageBit::kAllSampled & TextureUsageBit::kAllCompute;
@@ -173,7 +173,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
 		pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
 		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), readUsage,
-								  TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
+								  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 		pass.newTextureDependency(m_runCtx.m_upscaledHdrRt, writeUsage);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
@@ -189,7 +189,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Scale");
+			NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Scale");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
 			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
 
@@ -199,8 +199,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Scale");
-			pass.setRenderpassInfo({RenderTargetInfo(outRt)});
+			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Scale");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
 			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
 
@@ -226,7 +226,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Tonemap");
+			NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Tonemap");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
 			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
 
@@ -236,8 +236,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
-			pass.setRenderpassInfo({RenderTargetInfo(outRt)});
+			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
 			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
 
@@ -260,7 +260,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& pass = ctx.m_renderGraphDescr.newComputeRenderPass("Sharpen");
+			NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("Sharpen");
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
 			pass.newTextureDependency(outRt, TextureUsageBit::kStorageComputeWrite);
 
@@ -270,8 +270,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
-			pass.setRenderpassInfo({RenderTargetInfo(outRt)});
+			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
 			pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
 			pass.newTextureDependency(outRt, TextureUsageBit::kFramebufferWrite);
 
@@ -413,14 +413,13 @@ void Scale::runGrUpscaling(RenderingContext& ctx, RenderPassWorkContext& rgraphC
 
 	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-	const TextureView srcView = rgraphCtx.createTextureView(getRenderer().getLightShading().getRt(), TextureSubresourceDescriptor::firstSurface());
+	const TextureView srcView = rgraphCtx.createTextureView(getRenderer().getLightShading().getRt(), TextureSubresourceDesc::firstSurface());
 	const TextureView motionVectorsView =
-		rgraphCtx.createTextureView(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureSubresourceDescriptor::firstSurface());
-	const TextureView depthView = rgraphCtx.createTextureView(getRenderer().getGBuffer().getDepthRt(),
-															  TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
-	const TextureView exposureView =
-		rgraphCtx.createTextureView(getRenderer().getTonemapping().getRt(), TextureSubresourceDescriptor::firstSurface());
-	const TextureView dstView = rgraphCtx.createTextureView(m_runCtx.m_upscaledHdrRt, TextureSubresourceDescriptor::firstSurface());
+		rgraphCtx.createTextureView(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureSubresourceDesc::firstSurface());
+	const TextureView depthView =
+		rgraphCtx.createTextureView(getRenderer().getGBuffer().getDepthRt(), TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
+	const TextureView exposureView = rgraphCtx.createTextureView(getRenderer().getTonemapping().getRt(), TextureSubresourceDesc::firstSurface());
+	const TextureView dstView = rgraphCtx.createTextureView(m_runCtx.m_upscaledHdrRt, TextureSubresourceDesc::firstSurface());
 
 	cmdb.upscale(m_grUpscaler.get(), srcView, dstView, motionVectorsView, depthView, exposureView, reset, jitterOffset, mvScale);
 }

AnKi/Renderer/Scale.h

@@ -54,8 +54,8 @@ private:
 
 	GrUpscalerPtr m_grUpscaler;
 
-	RenderTargetDescription m_upscaleAndSharpenRtDescr;
-	RenderTargetDescription m_tonemapedRtDescr;
+	RenderTargetDesc m_upscaleAndSharpenRtDescr;
+	RenderTargetDesc m_tonemapedRtDescr;
 
 	enum class UpscalingMethod : U8
 	{

AnKi/Renderer/ShadowMapping.cpp

@@ -145,7 +145,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(ShadowMapping);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Import
 	if(m_rtImportedOnce) [[likely]]
@@ -273,7 +273,7 @@ void ShadowMapping::processLights(RenderingContext& ctx)
 
 	// Vars
 	const Vec3 cameraOrigin = ctx.m_matrices.m_cameraTransform.getTranslationPart().xyz();
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	const CameraComponent& mainCam = SceneGraph::getSingleton().getActiveCameraNode().getFirstComponentOfType<CameraComponent>();
 
 	// Allocate tiles for the dir light first but don't build any passes
@@ -580,13 +580,13 @@ void ShadowMapping::processLights(RenderingContext& ctx)
 }
 
 BufferView ShadowMapping::createVetVisibilityPass(CString passName, const LightComponent& lightc, const GpuVisibilityOutput& visOut,
-												  RenderGraphDescription& rgraph) const
+												  RenderGraphBuilder& rgraph) const
 {
 	BufferView clearTileIndirectArgs;
 
 	clearTileIndirectArgs = GpuVisibleTransientMemoryPool::getSingleton().allocate(sizeof(DrawIndirectArgs));
 
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passName);
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(passName);
 
 	// The shader doesn't actually write to the handle but have it as a write dependency for the drawer to correctly wait for this pass
 	pass.newBufferDependency(visOut.m_dependency, BufferUsageBit::kStorageComputeWrite);
@@ -616,7 +616,7 @@ BufferView ShadowMapping::createVetVisibilityPass(CString passName, const LightC
 
 void ShadowMapping::createDrawShadowsPass(const UVec4& viewport, const Mat4& viewProjMat, const Mat3x4& viewMat, const GpuVisibilityOutput& visOut,
 										  const GpuMeshletVisibilityOutput& meshletVisOut, const BufferView& clearTileIndirectArgs,
-										  const RenderTargetHandle hzbRt, CString passName, RenderGraphDescription& rgraph)
+										  const RenderTargetHandle hzbRt, CString passName, RenderGraphBuilder& rgraph)
 {
 	ShadowSubpassInfo spass;
 	spass.m_clearTileIndirectArgs = clearTileIndirectArgs;
@@ -629,7 +629,7 @@ void ShadowMapping::createDrawShadowsPass(const UVec4& viewport, const Mat4& vie
 }
 
 void ShadowMapping::createDrawShadowsPass(ConstWeakArray<ShadowSubpassInfo> subpasses_, const GpuVisibilityOutput& visOut,
-										  const GpuMeshletVisibilityOutput& meshletVisOut, CString passName, RenderGraphDescription& rgraph)
+										  const GpuMeshletVisibilityOutput& meshletVisOut, CString passName, RenderGraphBuilder& rgraph)
 {
 	WeakArray<ShadowSubpassInfo> subpasses;
 	newArray<ShadowSubpassInfo>(getRenderer().getFrameMemoryPool(), subpasses_.getSize(), subpasses);
@@ -656,11 +656,11 @@ void ShadowMapping::createDrawShadowsPass(ConstWeakArray<ShadowSubpassInfo> subp
 	}
 
 	// Create the pass
-	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(passName);
+	GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass(passName);
 
 	const Bool loadFb = !(subpasses.getSize() == 1 && subpasses[0].m_clearTileIndirectArgs.isValid());
 
-	RenderTargetInfo smRti(m_runCtx.m_rt);
+	GraphicsRenderPassTargetDesc smRti(m_runCtx.m_rt);
 	smRti.m_loadOperation = (loadFb) ? RenderTargetLoadOperation::kLoad : RenderTargetLoadOperation::kClear;
 	smRti.m_clearValue.m_depthStencil.m_depth = 1.0f;
 	smRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
@@ -713,7 +713,7 @@ void ShadowMapping::createDrawShadowsPass(ConstWeakArray<ShadowSubpassInfo> subp
 
 			if(spass.m_hzbRt.isValid())
 			{
-				args.m_hzbTexture = rgraphCtx.createTextureView(spass.m_hzbRt, TextureSubresourceDescriptor::all());
+				args.m_hzbTexture = rgraphCtx.createTextureView(spass.m_hzbRt, TextureSubresourceDesc::all());
 			}
 
 			if(meshletVisOut.isFilled())

AnKi/Renderer/ShadowMapping.h

@@ -62,7 +62,7 @@ private:
 	ShaderProgramResourcePtr m_vetVisibilityProg;
 	ShaderProgramPtr m_vetVisibilityGrProg;
 
-	Array<RenderTargetDescription, kMaxShadowCascades> m_cascadeHzbRtDescrs;
+	Array<RenderTargetDesc, kMaxShadowCascades> m_cascadeHzbRtDescrs;
 
 	class
 	{
@@ -81,14 +81,14 @@ private:
 	void chooseDetail(const Vec3& cameraOrigin, const LightComponent& lightc, Vec2 lodDistances, U32& tileAllocatorHierarchy) const;
 
 	BufferView createVetVisibilityPass(CString passName, const LightComponent& lightc, const GpuVisibilityOutput& visOut,
-									   RenderGraphDescription& rgraph) const;
+									   RenderGraphBuilder& rgraph) const;
 
 	void createDrawShadowsPass(const UVec4& viewport, const Mat4& viewProjMat, const Mat3x4& viewMat, const GpuVisibilityOutput& visOut,
 							   const GpuMeshletVisibilityOutput& meshletVisOut, const BufferView& clearTileIndirectArgs,
-							   const RenderTargetHandle hzbRt, CString passName, RenderGraphDescription& rgraph);
+							   const RenderTargetHandle hzbRt, CString passName, RenderGraphBuilder& rgraph);
 
 	void createDrawShadowsPass(ConstWeakArray<ShadowSubpassInfo> subPasses, const GpuVisibilityOutput& visOut,
-							   const GpuMeshletVisibilityOutput& meshletVisOut, CString passName, RenderGraphDescription& rgraph);
+							   const GpuMeshletVisibilityOutput& meshletVisOut, CString passName, RenderGraphBuilder& rgraph);
 };
 /// @}
 

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -53,12 +53,12 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(ShadowmapsResolve);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDescr);
 
 	if(g_preferComputeCVar.get())
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("ResolveShadows");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("ResolveShadows");
 
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			run(rgraphCtx, ctx);
@@ -80,9 +80,9 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("ResolveShadows");
+		GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("ResolveShadows");
 
-		rpass.setRenderpassInfo({RenderTargetInfo(m_runCtx.m_rt)});
+		rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_rt)});
 
 		rpass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			run(rgraphCtx, ctx);
@@ -129,7 +129,7 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx, RenderingContext&
 	{
 		rgraphCtx.bindTexture(ANKI_REG(t4), getRenderer().getGBuffer().getDepthRt());
 	}
-	cmdb.bindTexture(ANKI_REG(t5), TextureView(&m_noiseImage->getTexture(), TextureSubresourceDescriptor::all()));
+	cmdb.bindTexture(ANKI_REG(t5), TextureView(&m_noiseImage->getTexture(), TextureSubresourceDesc::all()));
 
 	if(getRenderer().getRtShadowsEnabled())
 	{

AnKi/Renderer/ShadowmapsResolve.h

@@ -42,7 +42,7 @@ public:
 public:
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
-	RenderTargetDescription m_rtDescr;
+	RenderTargetDesc m_rtDescr;
 	Bool m_quarterRez = false;
 	ImageResourcePtr m_noiseImage;
 

AnKi/Renderer/Sky.cpp

@@ -62,7 +62,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 		return;
 	}
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	const LightComponent* dirLightc = SceneGraph::getSingleton().getDirectionalLight();
 	ANKI_ASSERT(dirLightc);
@@ -101,7 +101,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	// Transmittance LUT
 	if(renderTransAndMultiScatLuts)
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("SkyTransmittanceLut");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("SkyTransmittanceLut");
 
 		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kStorageComputeWrite);
 
@@ -121,7 +121,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	// Multiple scattering LUT
 	if(renderTransAndMultiScatLuts)
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("SkyMultipleScatteringLut");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("SkyMultipleScatteringLut");
 
 		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kStorageComputeWrite);
@@ -144,7 +144,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 	// Sky LUT
 	if(renderSkyLut)
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("SkyLut");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("SkyLut");
 
 		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(multipleScatteringLutRt, TextureUsageBit::kSampledCompute);
@@ -169,7 +169,7 @@ void Sky::populateRenderGraph(RenderingContext& ctx)
 
 	// Compute sun color always
 	{
-		ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("ComputeSunColor");
+		NonGraphicsRenderPass& rpass = rgraph.newNonGraphicsRenderPass("ComputeSunColor");
 
 		rpass.newTextureDependency(transmittanceLutRt, TextureUsageBit::kSampledCompute);
 

AnKi/Renderer/Ssao.cpp

@@ -67,7 +67,7 @@ Error Ssao::initInternal()
 void Ssao::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(Ssao);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	const Bool preferCompute = g_preferComputeCVar.get();
 
 	const U32 readRtIdx = getRenderer().getFrameCount() & 1;
@@ -107,16 +107,16 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 	// Main pass
 	{
-		RenderPassDescriptionBase* ppass;
+		RenderPassBase* ppass;
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("SSAO");
+			NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("SSAO");
 			ppass = &pass;
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSAO");
-			pass.setRenderpassInfo({RenderTargetInfo(finalRt)});
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("SSAO");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(finalRt)});
 			ppass = &pass;
 		}
 
@@ -134,7 +134,7 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 			rgraphCtx.bindTexture(ANKI_REG(t1),
 								  (g_ssaoQuarterRez.get()) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt());
 
-			cmdb.bindTexture(ANKI_REG(t2), TextureView(&m_noiseImage->getTexture(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG(t2), TextureView(&m_noiseImage->getTexture(), TextureSubresourceDesc::all()));
 			cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearRepeat.get());
 			cmdb.bindSampler(ANKI_REG(s1), getRenderer().getSamplers().m_trilinearClamp.get());
 
@@ -171,17 +171,17 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 	// Spatial denoise
 	{
-		RenderPassDescriptionBase* ppass;
+		RenderPassBase* ppass;
 
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("SSAO spatial denoise");
+			NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("SSAO spatial denoise");
 			ppass = &pass;
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSAO spatial denoise");
-			pass.setRenderpassInfo({RenderTargetInfo(bentNormalsAndSsaoTempRt)});
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("SSAO spatial denoise");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(bentNormalsAndSsaoTempRt)});
 			ppass = &pass;
 		}
 
@@ -220,17 +220,17 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 
 	// Temporal denoise
 	{
-		RenderPassDescriptionBase* ppass;
+		RenderPassBase* ppass;
 
 		if(preferCompute)
 		{
-			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("SSAO temporal denoise");
+			NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("SSAO temporal denoise");
 			ppass = &pass;
 		}
 		else
 		{
-			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSAO temporal denoise");
-			pass.setRenderpassInfo({RenderTargetInfo(finalRt)});
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("SSAO temporal denoise");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(finalRt)});
 			ppass = &pass;
 		}
 

AnKi/Renderer/Ssao.h

@@ -45,7 +45,7 @@ public:
 	ShaderProgramPtr m_spatialDenoiseGrProg;
 	ShaderProgramPtr m_tempralDenoiseGrProg;
 
-	RenderTargetDescription m_bentNormalsAndSsaoRtDescr;
+	RenderTargetDesc m_bentNormalsAndSsaoRtDescr;
 
 	Array<TexturePtr, 2> m_tex;
 	Bool m_texImportedOnce = false;

AnKi/Renderer/Ssr.cpp

@@ -73,17 +73,17 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(Ssr);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 	const Bool preferCompute = g_preferComputeCVar.get();
 
 	m_runCtx.m_ssrRt = rgraph.newRenderTarget(m_ssrRtDescr);
 
 	TextureUsageBit readUsage;
 	TextureUsageBit writeUsage;
-	RenderPassDescriptionBase* ppass;
+	RenderPassBase* ppass;
 	if(preferCompute)
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("SSR");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("SSR");
 		ppass = &pass;
 
 		readUsage = TextureUsageBit::kSampledCompute;
@@ -92,9 +92,9 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 	else
 	{
 		// TODO
-		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSR");
+		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("SSR");
 
-		pass.setRenderpassInfo({RenderTargetInfo(m_runCtx.m_ssrRt)});
+		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_ssrRt)});
 
 		ppass = &pass;
 

AnKi/Renderer/Ssr.h

@@ -43,7 +43,7 @@ public:
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_ssrGrProg;
 
-	RenderTargetDescription m_ssrRtDescr;
+	RenderTargetDesc m_ssrRtDescr;
 
 	class
 	{

AnKi/Renderer/TemporalAA.cpp

@@ -55,7 +55,7 @@ Error TemporalAA::initInternal()
 void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(TemporalAA);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	const U32 historyRtIdx = (getRenderer().getFrameCount() + 1) & 1;
 	const U32 renderRtIdx = !historyRtIdx;
@@ -77,10 +77,10 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 
 	// Create pass
 	TextureUsageBit readUsage;
-	RenderPassDescriptionBase* prpass;
+	RenderPassBase* prpass;
 	if(preferCompute)
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("TemporalAA");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("TemporalAA");
 
 		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kStorageComputeWrite);
 		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kStorageComputeWrite);
@@ -91,8 +91,8 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("TemporalAA");
-		pass.setRenderpassInfo({RenderTargetInfo(m_runCtx.m_renderRt), RenderTargetInfo(m_runCtx.m_tonemappedRt)});
+		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("TemporalAA");
+		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_renderRt), GraphicsRenderPassTargetDesc(m_runCtx.m_tonemappedRt)});
 
 		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kFramebufferWrite);

AnKi/Renderer/TemporalAA.h

@@ -38,7 +38,7 @@ private:
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
-	RenderTargetDescription m_tonemappedRtDescr;
+	RenderTargetDesc m_tonemappedRtDescr;
 
 	class
 	{

AnKi/Renderer/Tonemapping.cpp

@@ -53,10 +53,10 @@ void Tonemapping::importRenderTargets(RenderingContext& ctx)
 void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(Tonemapping);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// Create the pass
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("AvgLuminance");
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("AvgLuminance");
 
 	pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 		ANKI_TRACE_SCOPED_EVENT(Tonemapping);
@@ -64,13 +64,13 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 
 		cmdb.bindShaderProgram(m_grProg.get());
 		rgraphCtx.bindTexture(ANKI_REG(u0), m_runCtx.m_exposureLuminanceHandle);
-		rgraphCtx.bindTexture(ANKI_REG(t0), getRenderer().getDownscaleBlur().getRt(), TextureSubresourceDescriptor::surface(m_inputTexMip, 0, 0));
+		rgraphCtx.bindTexture(ANKI_REG(t0), getRenderer().getDownscaleBlur().getRt(), TextureSubresourceDesc::surface(m_inputTexMip, 0, 0));
 
 		cmdb.dispatchCompute(1, 1, 1);
 	});
 
 	pass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
-							  TextureSubresourceDescriptor::surface(m_inputTexMip, 0, 0));
+							  TextureSubresourceDesc::surface(m_inputTexMip, 0, 0));
 }
 
 } // end namespace anki

AnKi/Renderer/Utils/Drawer.cpp

@@ -72,7 +72,7 @@ void RenderableDrawer::setState(const RenderableDrawerArguments& args, CommandBu
 	cmdb.bindStorageBuffer(ANKI_REG(ANKI_MATERIAL_REGISTER_TRANSFORMS), GpuSceneArrays::Transform::getSingleton().getBufferView());
 	cmdb.bindTexture(ANKI_REG(ANKI_MATERIAL_REGISTER_HZB_TEXTURE),
 					 (args.m_hzbTexture.isValid()) ? args.m_hzbTexture
-												   : TextureView(&getRenderer().getDummyTexture2d(), TextureSubresourceDescriptor::all()));
+												   : TextureView(&getRenderer().getDummyTexture2d(), TextureSubresourceDesc::all()));
 	cmdb.bindSampler(ANKI_REG(ANKI_MATERIAL_REGISTER_NEAREST_CLAMP_SAMPLER), getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 	// Misc

AnKi/Renderer/Utils/GpuVisibility.cpp

@@ -165,7 +165,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 		return;
 	}
 
-	RenderGraphDescription& rgraph = *in.m_rgraph;
+	RenderGraphBuilder& rgraph = *in.m_rgraph;
 
 	class DistanceTestData
 	{
@@ -324,7 +324,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 		Array<Char, 128> passName;
 		snprintf(passName.getBegin(), passName.getSizeInBytes(), "GPU vis zero: %s", in.m_passesName.cstr());
 
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passName.getBegin());
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(passName.getBegin());
 		pass.newBufferDependency(zeroStuffDependency, BufferUsageBit::kTransferDestination);
 
 		pass.setWork([out](RenderPassWorkContext& rpass) {
@@ -361,7 +361,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	out.m_dependency = mem.m_bufferDepedency;
 
 	// Create the renderpass
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("GPU vis: %s", in.m_passesName.cstr()));
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU vis: %s", in.m_passesName.cstr()));
 
 	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
 	pass.newBufferDependency(zeroStuffDependency, BufferUsageBit::kStorageComputeWrite);
@@ -516,7 +516,7 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 
 void GpuVisibility::populateRenderGraphMeshletInternal(Bool passthrough, BaseGpuMeshletVisibilityInput& in, GpuMeshletVisibilityOutput& out)
 {
-	RenderGraphDescription& rgraph = *in.m_rgraph;
+	RenderGraphBuilder& rgraph = *in.m_rgraph;
 
 	if(!in.m_taskShaderIndirectArgsBuffer.isValid()) [[unlikely]]
 	{
@@ -564,7 +564,7 @@ void GpuVisibility::populateRenderGraphMeshletInternal(Bool passthrough, BaseGpu
 	// Zero some stuff
 	const BufferHandle indirectArgsDep = rgraph.importBuffer(out.m_drawIndirectArgsBuffer, BufferUsageBit::kNone);
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("GPU meshlet vis zero: %s", in.m_passesName.cstr()));
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU meshlet vis zero: %s", in.m_passesName.cstr()));
 		pass.newBufferDependency(indirectArgsDep, BufferUsageBit::kTransferDestination);
 
 		pass.setWork([drawIndirectArgsBuffer = out.m_drawIndirectArgsBuffer](RenderPassWorkContext& rpass) {
@@ -579,7 +579,7 @@ void GpuVisibility::populateRenderGraphMeshletInternal(Bool passthrough, BaseGpu
 	out.m_dependency = mem.m_bufferDepedency;
 
 	// Create the renderpass
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("GPU meshlet vis: %s", in.m_passesName.cstr()));
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("GPU meshlet vis: %s", in.m_passesName.cstr()));
 
 	pass.newBufferDependency(indirectArgsDep, BufferUsageBit::kStorageComputeWrite);
 	pass.newBufferDependency(mem.m_bufferDepedency, BufferUsageBit::kStorageComputeWrite);
@@ -672,7 +672,7 @@ Error GpuVisibilityNonRenderables::init()
 void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderablesInput& in, GpuVisibilityNonRenderablesOutput& out)
 {
 	ANKI_ASSERT(in.m_viewProjectionMat != Mat4::getZero());
-	RenderGraphDescription& rgraph = *in.m_rgraph;
+	RenderGraphBuilder& rgraph = *in.m_rgraph;
 
 	U32 objCount = 0;
 	switch(in.m_objectType)
@@ -735,8 +735,8 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 
 		m_counterBufferZeroingHandle = rgraph.importBuffer(BufferView(m_counterBuffer.get()), buffInit.m_usage);
 
-		ComputeRenderPassDescription& pass =
-			rgraph.newComputeRenderPass(generateTempPassName("Non-renderables vis: Clear counter buff: %s", in.m_passesName.cstr()));
+		NonGraphicsRenderPass& pass =
+			rgraph.newNonGraphicsRenderPass(generateTempPassName("Non-renderables vis: Clear counter buff: %s", in.m_passesName.cstr()));
 
 		pass.newBufferDependency(m_counterBufferZeroingHandle, BufferUsageBit::kTransferDestination);
 
@@ -756,7 +756,7 @@ void GpuVisibilityNonRenderables::populateRenderGraph(GpuVisibilityNonRenderable
 	out.m_visiblesBufferHandle = rgraph.importBuffer(out.m_visiblesBuffer, BufferUsageBit::kNone);
 
 	// Create the renderpass
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("Non-renderables vis: %s", in.m_passesName.cstr()));
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("Non-renderables vis: %s", in.m_passesName.cstr()));
 
 	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
 	pass.newBufferDependency(out.m_visiblesBufferHandle, BufferUsageBit::kStorageComputeWrite);
@@ -844,7 +844,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 															  GpuVisibilityAccelerationStructuresOutput& out)
 {
 	in.validate();
-	RenderGraphDescription& rgraph = *in.m_rgraph;
+	RenderGraphBuilder& rgraph = *in.m_rgraph;
 
 #if ANKI_ASSERTIONS_ENABLED
 	ANKI_ASSERT(m_lastFrameIdx != getRenderer().getFrameCount());
@@ -863,7 +863,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 	// Create vis pass
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(generateTempPassName("Accel vis: %s", in.m_passesName.cstr()));
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass(generateTempPassName("Accel vis: %s", in.m_passesName.cstr()));
 
 		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
 		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
@@ -910,8 +910,8 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 	// Zero remaining instances
 	{
-		ComputeRenderPassDescription& pass =
-			rgraph.newComputeRenderPass(generateTempPassName("Accel vis zero remaining instances: %s", in.m_passesName.cstr()));
+		NonGraphicsRenderPass& pass =
+			rgraph.newNonGraphicsRenderPass(generateTempPassName("Accel vis zero remaining instances: %s", in.m_passesName.cstr()));
 
 		pass.newBufferDependency(out.m_someBufferHandle, BufferUsageBit::kStorageComputeWrite);
 

AnKi/Renderer/Utils/GpuVisibility.h

@@ -52,7 +52,7 @@ public:
 	Vec3 m_lodReferencePoint = Vec3(kMaxF32);
 	Array<F32, kMaxLodCount - 1> m_lodDistances = {};
 
-	RenderGraphDescription* m_rgraph = nullptr;
+	RenderGraphBuilder* m_rgraph = nullptr;
 
 	Bool m_gatherAabbIndices = false; ///< For debug draw.
 	Bool m_hashVisibles = false; ///< Create a hash for the visible renderables.
@@ -129,7 +129,7 @@ public:
 
 	BufferHandle m_dependency;
 
-	RenderGraphDescription* m_rgraph = nullptr;
+	RenderGraphBuilder* m_rgraph = nullptr;
 
 	void fillBuffers(const GpuVisibilityOutput& perObjVisOut)
 	{
@@ -297,7 +297,7 @@ public:
 	CString m_passesName;
 	GpuSceneNonRenderableObjectType m_objectType = GpuSceneNonRenderableObjectType::kCount;
 	Mat4 m_viewProjectionMat;
-	RenderGraphDescription* m_rgraph = nullptr;
+	RenderGraphBuilder* m_rgraph = nullptr;
 
 	const RenderTargetHandle* m_hzbRt = nullptr; ///< Optional.
 	BufferView m_cpuFeedbackBuffer; ///< Optional.
@@ -345,7 +345,7 @@ public:
 
 	Mat4 m_viewProjectionMatrix;
 
-	RenderGraphDescription* m_rgraph = nullptr;
+	RenderGraphBuilder* m_rgraph = nullptr;
 
 	void validate() const
 	{

AnKi/Renderer/Utils/HzbGenerator.cpp

@@ -85,7 +85,7 @@ Error HzbGenerator::init()
 }
 
 void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dispatchInputs, U32 firstCounterBufferElement, CString customName,
-											   RenderGraphDescription& rgraph) const
+											   RenderGraphBuilder& rgraph) const
 {
 	const U32 dispatchCount = dispatchInputs.getSize();
 
@@ -103,12 +103,12 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 	}
 #endif
 
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass((customName.isEmpty()) ? "HZB generation" : customName);
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass((customName.isEmpty()) ? "HZB generation" : customName);
 
 	Array<DispatchInput, kMaxShadowCascades> dispatchInputsCopy;
 	for(U32 i = 0; i < dispatchCount; ++i)
 	{
-		const TextureSubresourceDescriptor firstMipSubresource = TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth);
+		const TextureSubresourceDesc firstMipSubresource = TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(dispatchInputs[i].m_srcDepthRt, TextureUsageBit::kSampledCompute, firstMipSubresource);
 		pass.newTextureDependency(dispatchInputs[i].m_dstHzbRt, TextureUsageBit::kStorageComputeWrite);
 
@@ -152,7 +152,7 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 			Register mipsReg(ANKI_REG(u1));
 			for(U32 mip = 0; mip < kMaxMipsSinglePassDownsamplerCanProduce; ++mip)
 			{
-				TextureSubresourceDescriptor subresource = TextureSubresourceDescriptor::firstSurface();
+				TextureSubresourceDesc subresource = TextureSubresourceDesc::firstSurface();
 				if(mip < mipsToCompute)
 				{
 					subresource.m_mipmap = mip;
@@ -168,7 +168,7 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 
 			cmdb.bindStorageBuffer(
 				ANKI_REG(u0), BufferView(m_counterBuffer.get(), (firstCounterBufferElement + dispatch) * m_counterBufferElementSize, sizeof(U32)));
-			rgraphCtx.bindTexture(ANKI_REG(t0), in.m_srcDepthRt, TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
+			rgraphCtx.bindTexture(ANKI_REG(t0), in.m_srcDepthRt, TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 
 			cmdb.dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
 		}
@@ -176,7 +176,7 @@ void HzbGenerator::populateRenderGraphInternal(ConstWeakArray<DispatchInput> dis
 }
 
 void HzbGenerator::populateRenderGraph(RenderTargetHandle srcDepthRt, UVec2 srcDepthRtSize, RenderTargetHandle dstHzbRt, UVec2 dstHzbRtSize,
-									   RenderGraphDescription& rgraph, CString customName) const
+									   RenderGraphBuilder& rgraph, CString customName) const
 {
 	DispatchInput in;
 	in.m_dstHzbRt = dstHzbRt;
@@ -186,7 +186,7 @@ void HzbGenerator::populateRenderGraph(RenderTargetHandle srcDepthRt, UVec2 srcD
 	populateRenderGraphInternal({&in, 1}, 0, customName, rgraph);
 }
 
-void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLightInput& in, RenderGraphDescription& rgraph) const
+void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLightInput& in, RenderGraphBuilder& rgraph) const
 {
 	const U32 cascadeCount = in.m_cascadeCount;
 	ANKI_ASSERT(cascadeCount > 0);
@@ -196,14 +196,14 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 	constexpr U32 kTileSize = 64;
 	const UVec2 maxDepthRtSize = (in.m_depthBufferRtSize + kTileSize - 1) / kTileSize;
 	{
-		RenderTargetDescription maxDepthRtDescr("HZB max tile depth");
+		RenderTargetDesc maxDepthRtDescr("HZB max tile depth");
 		maxDepthRtDescr.m_width = maxDepthRtSize.x();
 		maxDepthRtDescr.m_height = maxDepthRtSize.y();
 		maxDepthRtDescr.m_format = Format::kR32_Sfloat;
 		maxDepthRtDescr.bake();
 		maxDepthRt = rgraph.newRenderTarget(maxDepthRtDescr);
 
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HZB max tile depth");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("HZB max tile depth");
 
 		pass.newTextureDependency(in.m_depthBufferRt, TextureUsageBit::kSampledCompute, DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kStorageComputeWrite);
@@ -211,7 +211,7 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 		pass.setWork([this, depthBufferRt = in.m_depthBufferRt, maxDepthRt, maxDepthRtSize](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-			rgraphCtx.bindTexture(ANKI_REG(t0), depthBufferRt, TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth));
+			rgraphCtx.bindTexture(ANKI_REG(t0), depthBufferRt, TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 			cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearClamp.get());
 			rgraphCtx.bindTexture(ANKI_REG(u0), maxDepthRt);
 
@@ -256,16 +256,16 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 			ANKI_ASSERT(cascadeMinDepth <= cascadeMaxDepth);
 		}
 
-		RenderTargetDescription depthRtDescr(generateTempPassName("HZB boxes depth cascade:%u", i));
+		RenderTargetDesc depthRtDescr(generateTempPassName("HZB boxes depth cascade:%u", i));
 		depthRtDescr.m_width = cascade.m_hzbRtSize.x() * 2;
 		depthRtDescr.m_height = cascade.m_hzbRtSize.y() * 2;
 		depthRtDescr.m_format = Format::kD16_Unorm;
 		depthRtDescr.bake();
 		depthRts[i] = rgraph.newRenderTarget(depthRtDescr);
 
-		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("HZB boxes");
+		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("HZB boxes");
 
-		RenderTargetInfo depthRt(depthRts[i]);
+		GraphicsRenderPassTargetDesc depthRt(depthRts[i]);
 		depthRt.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 		depthRt.m_clearValue.m_depthStencil.m_depth = 0.0f;
 		depthRt.m_loadOperation = RenderTargetLoadOperation::kClear;

AnKi/Renderer/Utils/HzbGenerator.h

@@ -44,9 +44,9 @@ public:
 	Error init();
 
 	void populateRenderGraph(RenderTargetHandle srcDepthRt, UVec2 srcDepthRtSize, RenderTargetHandle dstHzbRt, UVec2 dstHzbRtSize,
-							 RenderGraphDescription& rgraph, CString customName = {}) const;
+							 RenderGraphBuilder& rgraph, CString customName = {}) const;
 
-	void populateRenderGraphDirectionalLight(const HzbDirectionalLightInput& in, RenderGraphDescription& rgraph) const;
+	void populateRenderGraphDirectionalLight(const HzbDirectionalLightInput& in, RenderGraphBuilder& rgraph) const;
 
 private:
 	class DispatchInput
@@ -83,7 +83,7 @@ private:
 #endif
 
 	void populateRenderGraphInternal(ConstWeakArray<DispatchInput> dispatchInputs, U32 firstCounterBufferElement, CString customName,
-									 RenderGraphDescription& rgraph) const;
+									 RenderGraphBuilder& rgraph) const;
 };
 /// @}
 

AnKi/Renderer/Utils/MipmapGenerator.cpp

@@ -16,7 +16,7 @@ Error MipmapGenerator::init()
 	return Error::kNone;
 }
 
-void MipmapGenerator::populateRenderGraph(const MipmapGeneratorTargetArguments& target, RenderGraphDescription& rgraph, CString passesName)
+void MipmapGenerator::populateRenderGraph(const MipmapGeneratorTargetArguments& target, RenderGraphBuilder& rgraph, CString passesName)
 {
 	for(U32 readMip = 0; readMip < target.m_mipmapCount - 1u; ++readMip)
 	{
@@ -25,17 +25,16 @@ void MipmapGenerator::populateRenderGraph(const MipmapGeneratorTargetArguments&
 		{
 			for(U32 layer = 0; layer < target.m_layerCount; ++layer)
 			{
-				GraphicsRenderPassDescription& rpass =
+				GraphicsRenderPass& rpass =
 					rgraph.newGraphicsRenderPass(generateTempPassName("%s: mip #%u face #%u layer #%u", passesName.cstr(), readMip, face, layer));
 
-				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kSampledFragment,
-										   TextureSubresourceDescriptor::surface(readMip, face, layer));
+				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kSampledFragment, TextureSubresourceDesc::surface(readMip, face, layer));
 				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kFramebufferWrite,
-										   TextureSubresourceDescriptor::surface(readMip + 1, face, layer));
+										   TextureSubresourceDesc::surface(readMip + 1, face, layer));
 
-				RenderTargetInfo rtInfo;
+				GraphicsRenderPassTargetDesc rtInfo;
 				rtInfo.m_handle = target.m_handle;
-				rtInfo.m_subresource = TextureSubresourceDescriptor::surface(readMip + 1, face, layer);
+				rtInfo.m_subresource = TextureSubresourceDesc::surface(readMip + 1, face, layer);
 				rpass.setRenderpassInfo({rtInfo});
 
 				rpass.setWork([this, rt = target.m_handle, readMip, face, layer,
@@ -47,7 +46,7 @@ void MipmapGenerator::populateRenderGraph(const MipmapGeneratorTargetArguments&
 					cmdb.bindShaderProgram(m_genMipsGrProg.get());
 					cmdb.setViewport(0, 0, viewport.x(), viewport.y());
 
-					rgraphCtx.bindTexture(ANKI_REG(t0), rt, TextureSubresourceDescriptor::surface(readMip, face, layer));
+					rgraphCtx.bindTexture(ANKI_REG(t0), rt, TextureSubresourceDesc::surface(readMip, face, layer));
 					cmdb.bindSampler(ANKI_REG(s0), getRenderer().getSamplers().m_trilinearClamp.get());
 
 					drawQuad(cmdb);

AnKi/Renderer/Utils/MipmapGenerator.h

@@ -29,7 +29,7 @@ class MipmapGenerator : public RendererObject
 public:
 	Error init();
 
-	void populateRenderGraph(const MipmapGeneratorTargetArguments& target, RenderGraphDescription& rgraph, CString passesName = {});
+	void populateRenderGraph(const MipmapGeneratorTargetArguments& target, RenderGraphBuilder& rgraph, CString passesName = {});
 
 private:
 	ShaderProgramResourcePtr m_genMipsProg;

AnKi/Renderer/Utils/TraditionalDeferredShading.cpp

@@ -75,7 +75,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		else if(skyc->getSkyboxType() == SkyboxType::kImage2D)
 		{
 			cmdb.bindSampler(ANKI_REG(s1), getRenderer().getSamplers().m_trilinearRepeatAniso.get());
-			cmdb.bindTexture(ANKI_REG(t1), TextureView(&skyc->getImageResource().getTexture(), TextureSubresourceDescriptor::all()));
+			cmdb.bindTexture(ANKI_REG(t1), TextureView(&skyc->getImageResource().getTexture(), TextureSubresourceDesc::all()));
 		}
 		else
 		{

AnKi/Renderer/Utils/TraditionalDeferredShading.h

@@ -29,15 +29,14 @@ public:
 
 	// Render targets
 	Array<RenderTargetHandle, kGBufferColorRenderTargetCount - 1> m_gbufferRenderTargets;
-	Array<TextureSubresourceDescriptor, kGBufferColorRenderTargetCount - 1> m_gbufferRenderTargetSubresource{
-		TextureSubresourceDescriptor::firstSurface(), TextureSubresourceDescriptor::firstSurface(), TextureSubresourceDescriptor::firstSurface()};
+	Array<TextureSubresourceDesc, kGBufferColorRenderTargetCount - 1> m_gbufferRenderTargetSubresource{
+		TextureSubresourceDesc::firstSurface(), TextureSubresourceDesc::firstSurface(), TextureSubresourceDesc::firstSurface()};
 
 	RenderTargetHandle m_gbufferDepthRenderTarget;
-	TextureSubresourceDescriptor m_gbufferDepthRenderTargetSubresource = TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth);
+	TextureSubresourceDesc m_gbufferDepthRenderTargetSubresource = TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth);
 
 	RenderTargetHandle m_directionalLightShadowmapRenderTarget;
-	TextureSubresourceDescriptor m_directionalLightShadowmapRenderTargetSubresource =
-		TextureSubresourceDescriptor::firstSurface(DepthStencilAspectBit::kDepth);
+	TextureSubresourceDesc m_directionalLightShadowmapRenderTargetSubresource = TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth);
 
 	RenderTargetHandle m_skyLutRenderTarget;
 	BufferView m_globalRendererConsts;

AnKi/Renderer/VolumetricFog.cpp

@@ -43,11 +43,11 @@ Error VolumetricFog::init()
 void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(VolumetricFog);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDescr);
 
-	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol fog");
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Vol fog");
 
 	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
 	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);

AnKi/Renderer/VolumetricFog.h

@@ -41,7 +41,7 @@ private:
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
-	RenderTargetDescription m_rtDescr;
+	RenderTargetDesc m_rtDescr;
 
 	U32 m_finalZSplit = 0;
 

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -62,14 +62,14 @@ Error VolumetricLightingAccumulation::init()
 void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(VolumetricLightingAccumulation);
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	const U readRtIdx = getRenderer().getFrameCount() & 1;
 
 	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");
+	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Vol light");
 
 	pass.newTextureDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute);
 	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kStorageComputeWrite);
@@ -102,7 +102,7 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 		rgraphCtx.bindTexture(ANKI_REG(u0), m_runCtx.m_rts[1]);
 
-		cmdb.bindTexture(ANKI_REG(t0), TextureView(&m_noiseImage->getTexture(), TextureSubresourceDescriptor::all()));
+		cmdb.bindTexture(ANKI_REG(t0), TextureView(&m_noiseImage->getTexture(), TextureSubresourceDesc::all()));
 
 		rgraphCtx.bindTexture(ANKI_REG(t1), m_runCtx.m_rts[0]);
 

AnKi/Renderer/VrsSriGeneration.cpp

@@ -125,11 +125,11 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 	ANKI_TRACE_SCOPED_EVENT(VrsSriGeneration);
 
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	RenderGraphBuilder& rgraph = ctx.m_renderGraphDescr;
 
 	// SRI generation
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI generation");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("VRS SRI generation");
 
 		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
 		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSampledCompute);
@@ -154,7 +154,7 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 	// Downscale
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI downscale");
+		NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("VRS SRI downscale");
 
 		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute);
 		pass.newTextureDependency(m_runCtx.m_downscaledRt, TextureUsageBit::kStorageComputeWrite);

AnKi/Resource/ImageResource.cpp

@@ -198,7 +198,7 @@ Error ImageResource::load(const ResourceFilename& filename, Bool async)
 
 	// Transition it. TODO remove this
 	{
-		const TextureView view(m_tex.get(), TextureSubresourceDescriptor::all());
+		const TextureView view(m_tex.get(), TextureSubresourceDesc::all());
 
 		CommandBufferInitInfo cmdbinit;
 		cmdbinit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
@@ -256,8 +256,8 @@ Error ImageResource::load(LoadingContext& ctx)
 			U32 mip, layer, face;
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
-			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDescriptor::surface(mip, face, layer)),
-										TextureUsageBit::kAllSampled, TextureUsageBit::kTransferDestination};
+			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDesc::surface(mip, face, layer)), TextureUsageBit::kAllSampled,
+										TextureUsageBit::kTransferDestination};
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
 
@@ -300,7 +300,7 @@ Error ImageResource::load(LoadingContext& ctx)
 			memcpy(data, surfOrVolData, surfOrVolSize);
 
 			// Create temp tex view
-			const TextureSubresourceDescriptor subresource = TextureSubresourceDescriptor::surface(mip, face, layer);
+			const TextureSubresourceDesc subresource = TextureSubresourceDesc::surface(mip, face, layer);
 			cmdb->copyBufferToTexture(handle, TextureView(ctx.m_tex.get(), subresource));
 		}
 
@@ -311,7 +311,7 @@ Error ImageResource::load(LoadingContext& ctx)
 			U32 mip, layer, face;
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
-			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDescriptor::surface(mip, face, layer)),
+			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDesc::surface(mip, face, layer)),
 										TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledGeometry};
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});

AnKi/Resource/MaterialResource.cpp

@@ -454,7 +454,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->getTexture().getOrCreateBindlessTextureIndex(TextureSubresourceDescriptor::all());
+			foundVar->m_U32 = foundVar->m_image->getTexture().getOrCreateBindlessTextureIndex(TextureSubresourceDesc::all());
 		}
 		else
 		{

AnKi/Scene/Components/DecalComponent.cpp

@@ -37,7 +37,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->getTexture().getOrCreateBindlessTextureIndex(TextureSubresourceDescriptor::all());
+	l.m_bindlessTextureIndex = l.m_image->getTexture().getOrCreateBindlessTextureIndex(TextureSubresourceDesc::all());
 	l.m_blendFactor = blendFactor;
 }
 

AnKi/Scene/Components/GlobalIlluminationProbeComponent.cpp

@@ -53,7 +53,7 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 		texInit.m_usage = TextureUsageBit::kAllSampled | TextureUsageBit::kStorageComputeWrite | TextureUsageBit::kStorageComputeRead;
 
 		m_volTex = GrManager::getSingleton().newTexture(texInit);
-		m_volTexBindlessIdx = m_volTex->getOrCreateBindlessTextureIndex(TextureSubresourceDescriptor::all());
+		m_volTexBindlessIdx = m_volTex->getOrCreateBindlessTextureIndex(TextureSubresourceDesc::all());
 
 		// Zero the texture
 		const ShaderProgramResourceVariant* variant;
@@ -69,11 +69,11 @@ Error GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, B
 		TextureBarrierInfo texBarrier;
 		texBarrier.m_previousUsage = TextureUsageBit::kNone;
 		texBarrier.m_nextUsage = TextureUsageBit::kStorageComputeWrite;
-		texBarrier.m_textureView = TextureView(m_volTex.get(), TextureSubresourceDescriptor::all());
+		texBarrier.m_textureView = TextureView(m_volTex.get(), TextureSubresourceDesc::all());
 		cmdb->setPipelineBarrier({&texBarrier, 1}, {}, {});
 
 		cmdb->bindShaderProgram(&variant->getProgram());
-		cmdb->bindTexture(ANKI_REG(u0), TextureView(m_volTex.get(), TextureSubresourceDescriptor::all()));
+		cmdb->bindTexture(ANKI_REG(u0), TextureView(m_volTex.get(), TextureSubresourceDesc::all()));
 
 		const Vec4 clearColor(0.0f);
 		cmdb->setPushConstants(&clearColor, sizeof(clearColor));

AnKi/Scene/Components/ReflectionProbeComponent.cpp

@@ -33,7 +33,7 @@ ReflectionProbeComponent::ReflectionProbeComponent(SceneNode* node)
 
 	m_reflectionTex = GrManager::getSingleton().newTexture(texInit);
 
-	m_reflectionTexBindlessIndex = m_reflectionTex->getOrCreateBindlessTextureIndex(TextureSubresourceDescriptor::all());
+	m_reflectionTexBindlessIndex = m_reflectionTex->getOrCreateBindlessTextureIndex(TextureSubresourceDesc::all());
 }
 
 ReflectionProbeComponent::~ReflectionProbeComponent()

AnKi/Ui/Font.cpp

@@ -80,11 +80,11 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	m_tex = GrManager::getSingleton().newTexture(texInit);
 
 	// Create the whole texture view
-	m_imgData.m_textureView = TextureView(m_tex.get(), TextureSubresourceDescriptor::all());
+	m_imgData.m_textureView = TextureView(m_tex.get(), TextureSubresourceDesc::all());
 	m_imFontAtlas->SetTexID(UiImageId(&m_imgData));
 
 	// Do the copy
-	const TextureView firstMipView(m_tex.get(), TextureSubresourceDescriptor::firstSurface());
+	const TextureView firstMipView(m_tex.get(), TextureSubresourceDesc::firstSurface());
 
 	CommandBufferInitInfo cmdbInit;
 	cmdbInit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;

Tests/Gr/Gr.cpp

@@ -93,7 +93,7 @@ TexturePtr createTexture2d(const TextureInitInfo& texInit, T initialValue)
 
 	CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);
 
-	cmdb->copyBufferToTexture(BufferView(staging.get()), TextureView(tex.get(), TextureSubresourceDescriptor::all()));
+	cmdb->copyBufferToTexture(BufferView(staging.get()), TextureView(tex.get(), TextureSubresourceDesc::all()));
 	cmdb->endRecording();
 
 	FencePtr fence;
@@ -190,18 +190,18 @@ ANKI_TEST(Gr, ClearScreen)
 		cinit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 		CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cinit);
 
-		const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDescriptor::all()), TextureUsageBit::kNone,
+		const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
 											TextureUsageBit::kFramebufferWrite};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 		RenderTarget rt;
-		rt.m_textureView = TextureView(presentTex.get(), TextureSubresourceDescriptor::all());
+		rt.m_textureView = TextureView(presentTex.get(), TextureSubresourceDesc::all());
 		const F32 col = 1.0f - F32(iterations) / F32(kIterations);
 		rt.m_clearValue.m_colorf = {col, 0.0f, col, 1.0f};
 		cmdb->beginRenderPass({rt});
 		cmdb->endRenderPass();
 
-		const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDescriptor::all()), TextureUsageBit::kFramebufferWrite,
+		const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kFramebufferWrite,
 											 TextureUsageBit::kPresent};
 		cmdb->setPipelineBarrier({&barrier2, 1}, {}, {});
 
@@ -385,7 +385,7 @@ void main()
 		SamplerInitInfo samplInit;
 		SamplerPtr sampler = GrManager::getSingleton().newSampler(samplInit);
 
-		const U32 bindlessIdx = tex->getOrCreateBindlessTextureIndex(TextureSubresourceDescriptor::all());
+		const U32 bindlessIdx = tex->getOrCreateBindlessTextureIndex(TextureSubresourceDesc::all());
 
 		// Record
 		CommandBufferInitInfo cmdbInit;
@@ -394,12 +394,12 @@ void main()
 
 		cmdb->bindShaderProgram(prog.get());
 		cmdb->bindStorageBuffer(ANKI_REG(t0), BufferView(structured.get()));
-		cmdb->bindTexture(ANKI_REG(t2), TextureView(tex.get(), TextureSubresourceDescriptor::all()));
+		cmdb->bindTexture(ANKI_REG(t2), TextureView(tex.get(), TextureSubresourceDesc::all()));
 		cmdb->bindTexelBuffer(ANKI_REG(t3), BufferView(buff.get()), Format::kR32G32B32A32_Sfloat);
 		cmdb->bindStorageBuffer(ANKI_REG2(u0, space2), BufferView(rwstructured.get()));
-		cmdb->bindTexture(ANKI_REG(u2), TextureView(rwtex[0].get(), TextureSubresourceDescriptor::firstSurface()));
-		cmdb->bindTexture(ANKI_REG(u3), TextureView(rwtex[1].get(), TextureSubresourceDescriptor::firstSurface()));
-		cmdb->bindTexture(ANKI_REG(u4), TextureView(rwtex[2].get(), TextureSubresourceDescriptor::firstSurface()));
+		cmdb->bindTexture(ANKI_REG(u2), TextureView(rwtex[0].get(), TextureSubresourceDesc::firstSurface()));
+		cmdb->bindTexture(ANKI_REG(u3), TextureView(rwtex[1].get(), TextureSubresourceDesc::firstSurface()));
+		cmdb->bindTexture(ANKI_REG(u4), TextureView(rwtex[2].get(), TextureSubresourceDesc::firstSurface()));
 		cmdb->bindTexelBuffer(ANKI_REG(u7), BufferView(rwbuff.get()), Format::kR32G32B32A32_Sfloat);
 		cmdb->bindUniformBuffer(ANKI_REG(b0), BufferView(consts.get()));
 		cmdb->bindSampler(ANKI_REG(s2), sampler.get());
@@ -744,13 +744,13 @@ float4 main(VertOut i) : SV_TARGET0
 			cmdb->setViewport(0, 0, NativeWindow::getSingleton().getWidth(), NativeWindow::getSingleton().getHeight());
 			cmdb->bindShaderProgram(prog.get());
 
-			const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDescriptor::all()), TextureUsageBit::kNone,
+			const TextureBarrierInfo barrier = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kNone,
 												TextureUsageBit::kFramebufferWrite};
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			cmdb->pushDebugMarker("AnKi", Vec3(1.0f, 0.0f, 0.0f));
 
-			cmdb->beginRenderPass({TextureView(presentTex.get(), TextureSubresourceDescriptor::firstSurface())});
+			cmdb->beginRenderPass({TextureView(presentTex.get(), TextureSubresourceDesc::firstSurface())});
 
 			// Set uniforms
 			class A
@@ -775,8 +775,8 @@ float4 main(VertOut i) : SV_TARGET0
 			cmdb->draw(PrimitiveTopology::kTriangles, 3);
 			cmdb->endRenderPass();
 
-			const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDescriptor::all()),
-												 TextureUsageBit::kFramebufferWrite, TextureUsageBit::kPresent};
+			const TextureBarrierInfo barrier2 = {TextureView(presentTex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kFramebufferWrite,
+												 TextureUsageBit::kPresent};
 			cmdb->setPipelineBarrier({&barrier2, 1}, {}, {});
 
 			cmdb->popDebugMarker();
@@ -1499,9 +1499,9 @@ ANKI_TEST(Gr, 3DTextures)
 #endif
 }
 
-static RenderTargetDescription newRTDescr(CString name)
+static RenderTargetDesc newRTDescr(CString name)
 {
-	RenderTargetDescription texInf(name);
+	RenderTargetDesc texInf(name);
 	texInf.m_width = texInf.m_height = 16;
 	texInf.m_usage = TextureUsageBit::kFramebufferWrite | TextureUsageBit::kSampledFragment;
 	texInf.m_format = Format::kR8G8B8A8_Unorm;
@@ -1515,7 +1515,7 @@ ANKI_TEST(Gr, RenderGraph)
 	COMMON_BEGIN()
 
 	StackMemoryPool pool(allocAligned, nullptr, 2_MB);
-	RenderGraphDescription descr(&pool);
+	RenderGraphBuilder descr(&pool);
 	RenderGraphPtr rgraph = g_gr->newRenderGraph();
 
 	const U GI_MIP_COUNT = 4;
@@ -1529,14 +1529,14 @@ ANKI_TEST(Gr, RenderGraph)
 	// SM
 	RenderTargetHandle smScratchRt = descr.newRenderTarget(newRTDescr("SM scratch"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SM");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("SM");
 		pass.newTextureDependency(smScratchRt, TextureUsageBit::kAllFramebuffer);
 	}
 
 	// SM to exponential SM
 	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("ESM");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("ESM");
 		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSampledFragment);
 		pass.newTextureDependency(smExpRt, TextureUsageBit::kFramebufferWrite);
 	}
@@ -1546,7 +1546,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle giGbuffDiffRt = descr.newRenderTarget(newRTDescr("GI GBuff diff"));
 	RenderTargetHandle giGbuffDepthRt = descr.newRenderTarget(newRTDescr("GI GBuff depth"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("GI gbuff");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("GI gbuff");
 		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kFramebufferWrite);
@@ -1558,7 +1558,7 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		TextureSubresourceInfo subresource(TextureSurfaceDescriptor(0, faceIdx, 0));
 
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass(String().sprintf("GI lp%u", faceIdx).toCString());
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass(String().sprintf("GI lp%u", faceIdx).toCString());
 		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kFramebufferWrite, subresource);
 		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kSampledFragment);
 		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kSampledFragment);
@@ -1569,7 +1569,7 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
 		{
-			GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass(String().sprintf("GI mip%u", faceIdx).toCString());
+			GraphicsRenderPass& pass = descr.newGraphicsRenderPass(String().sprintf("GI mip%u", faceIdx).toCString());
 
 			for(U32 mip = 0; mip < GI_MIP_COUNT; ++mip)
 			{
@@ -1585,7 +1585,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle gbuffRt2 = descr.newRenderTarget(newRTDescr("GBuff RT2"));
 	RenderTargetHandle gbuffDepth = descr.newRenderTarget(newRTDescr("GBuff RT2"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("G-Buffer");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("G-Buffer");
 		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kFramebufferWrite);
@@ -1595,7 +1595,7 @@ ANKI_TEST(Gr, RenderGraph)
 	// Half depth
 	RenderTargetHandle halfDepthRt = descr.newRenderTarget(newRTDescr("Depth/2"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("HalfDepth");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("HalfDepth");
 		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSampledFragment);
 		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kFramebufferWrite);
 	}
@@ -1603,7 +1603,7 @@ ANKI_TEST(Gr, RenderGraph)
 	// Quarter depth
 	RenderTargetHandle quarterDepthRt = descr.newRenderTarget(newRTDescr("Depth/4"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("QuarterDepth");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("QuarterDepth");
 		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSampledFragment);
 	}
@@ -1611,17 +1611,17 @@ ANKI_TEST(Gr, RenderGraph)
 	// SSAO
 	RenderTargetHandle ssaoRt = descr.newRenderTarget(newRTDescr("SSAO"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SSAO main");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("SSAO main");
 		pass.newTextureDependency(ssaoRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSampledFragment);
 		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSampledFragment);
 
 		RenderTargetHandle ssaoVBlurRt = descr.newRenderTarget(newRTDescr("SSAO tmp"));
-		GraphicsRenderPassDescription& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
+		GraphicsRenderPass& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
 		pass2.newTextureDependency(ssaoRt, TextureUsageBit::kSampledFragment);
 		pass2.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kFramebufferWrite);
 
-		GraphicsRenderPassDescription& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
+		GraphicsRenderPass& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
 		pass3.newTextureDependency(ssaoRt, TextureUsageBit::kFramebufferWrite);
 		pass3.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kSampledFragment);
 	}
@@ -1629,16 +1629,16 @@ ANKI_TEST(Gr, RenderGraph)
 	// Volumetric
 	RenderTargetHandle volRt = descr.newRenderTarget(newRTDescr("Vol"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Vol main");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Vol main");
 		pass.newTextureDependency(volRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSampledFragment);
 
 		RenderTargetHandle volVBlurRt = descr.newRenderTarget(newRTDescr("Vol tmp"));
-		GraphicsRenderPassDescription& pass2 = descr.newGraphicsRenderPass("Vol vblur");
+		GraphicsRenderPass& pass2 = descr.newGraphicsRenderPass("Vol vblur");
 		pass2.newTextureDependency(volRt, TextureUsageBit::kSampledFragment);
 		pass2.newTextureDependency(volVBlurRt, TextureUsageBit::kFramebufferWrite);
 
-		GraphicsRenderPassDescription& pass3 = descr.newGraphicsRenderPass("Vol hblur");
+		GraphicsRenderPass& pass3 = descr.newGraphicsRenderPass("Vol hblur");
 		pass3.newTextureDependency(volRt, TextureUsageBit::kFramebufferWrite);
 		pass3.newTextureDependency(volVBlurRt, TextureUsageBit::kSampledFragment);
 	}
@@ -1646,7 +1646,7 @@ ANKI_TEST(Gr, RenderGraph)
 	// Forward shading
 	RenderTargetHandle fsRt = descr.newRenderTarget(newRTDescr("FS"));
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Forward shading");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Forward shading");
 		pass.newTextureDependency(fsRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
 		pass.newTextureDependency(volRt, TextureUsageBit::kSampledFragment);
@@ -1655,7 +1655,7 @@ ANKI_TEST(Gr, RenderGraph)
 	// Light shading
 	RenderTargetHandle lightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kNone);
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Light shading");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Light shading");
 
 		pass.newTextureDependency(lightRt, TextureUsageBit::kFramebufferWrite);
 		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kSampledFragment);
@@ -1672,7 +1672,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
 	RenderTargetHandle taaRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kNone);
 	{
-		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Temporal AA");
+		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Temporal AA");
 
 		pass.newTextureDependency(lightRt, TextureUsageBit::kSampledFragment);
 		pass.newTextureDependency(taaRt, TextureUsageBit::kFramebufferWrite);

Tests/Gr/GrMeshShaders.cpp

@@ -230,13 +230,13 @@ float3 main(VertOut input) : SV_TARGET0
 			cmdb->setViewport(0, 0, g_windowWidthCVar.get(), g_windowHeightCVar.get());
 
 			TextureBarrierInfo barrier;
-			barrier.m_textureView = TextureView(swapchainTex.get(), TextureSubresourceDescriptor::all());
+			barrier.m_textureView = TextureView(swapchainTex.get(), TextureSubresourceDesc::all());
 			barrier.m_previousUsage = TextureUsageBit::kNone;
 			barrier.m_nextUsage = TextureUsageBit::kFramebufferWrite;
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			RenderTarget rt;
-			rt.m_textureView = TextureView(swapchainTex.get(), TextureSubresourceDescriptor::all());
+			rt.m_textureView = TextureView(swapchainTex.get(), TextureSubresourceDesc::all());
 			rt.m_clearValue.m_colorf = {1.0f, 0.0f, 1.0f, 0.0f};
 			cmdb->beginRenderPass({rt});
 

Tests/Ui/Ui.cpp

@@ -107,11 +107,11 @@ ANKI_TEST(Ui, Ui)
 			TextureBarrierInfo barrier;
 			barrier.m_previousUsage = TextureUsageBit::kNone;
 			barrier.m_nextUsage = TextureUsageBit::kFramebufferWrite;
-			barrier.m_textureView = TextureView(presentTex.get(), TextureSubresourceDescriptor::all());
+			barrier.m_textureView = TextureView(presentTex.get(), TextureSubresourceDesc::all());
 			cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 			RenderTarget rt;
-			rt.m_textureView = TextureView(presentTex.get(), TextureSubresourceDescriptor::all());
+			rt.m_textureView = TextureView(presentTex.get(), TextureSubresourceDesc::all());
 			rt.m_clearValue.m_colorf = {{1.0, 0.0, 1.0, 1.0}};
 			cmdb->beginRenderPass({rt});
 

Tools/Image/ImageViewerMain.cpp

@@ -31,7 +31,7 @@ public:
 	{
 		if(!m_imageIdExtra.m_textureView.isValid())
 		{
-			m_imageIdExtra.m_textureView = TextureView(&m_imageResource->getTexture(), TextureSubresourceDescriptor::all());
+			m_imageIdExtra.m_textureView = TextureView(&m_imageResource->getTexture(), TextureSubresourceDesc::all());
 		}
 
 		return Error::kNone;
@@ -142,7 +142,7 @@ private:
 			if(lastCrntMip != m_crntMip)
 			{
 				// Re-create the image view
-				m_imageIdExtra.m_textureView = TextureView(&m_imageResource->getTexture(), TextureSubresourceDescriptor::surface(m_crntMip, 0, 0));
+				m_imageIdExtra.m_textureView = TextureView(&m_imageResource->getTexture(), TextureSubresourceDesc::surface(m_crntMip, 0, 0));
 			}
 
 			ImGui::SameLine();