Some renaming

AnKi/Gr/Common.h

@@ -952,32 +952,32 @@ public:
 };
 
 /// A way to identify a surface in a texture.
-class TextureSurfaceInfo
+class TextureSurfaceDescriptor
 {
 public:
 	U32 m_level = 0;
 	U32 m_face = 0;
 	U32 m_layer = 0;
 
-	constexpr TextureSurfaceInfo() = default;
+	constexpr TextureSurfaceDescriptor() = default;
 
-	constexpr TextureSurfaceInfo(const TextureSurfaceInfo&) = default;
+	constexpr TextureSurfaceDescriptor(const TextureSurfaceDescriptor&) = default;
 
-	constexpr TextureSurfaceInfo(U32 level, U32 face, U32 layer)
+	constexpr TextureSurfaceDescriptor(U32 level, U32 face, U32 layer)
 		: m_level(level)
 		, m_face(face)
 		, m_layer(layer)
 	{
 	}
 
-	TextureSurfaceInfo& operator=(const TextureSurfaceInfo&) = default;
+	TextureSurfaceDescriptor& operator=(const TextureSurfaceDescriptor&) = default;
 
-	Bool operator==(const TextureSurfaceInfo& b) const
+	Bool operator==(const TextureSurfaceDescriptor& b) const
 	{
 		return m_level == b.m_level && m_face == b.m_face && m_layer == b.m_layer;
 	}
 
-	Bool operator!=(const TextureSurfaceInfo& b) const
+	Bool operator!=(const TextureSurfaceDescriptor& b) const
 	{
 		return !(*this == b);
 	}
@@ -987,28 +987,28 @@ public:
 		return anki::computeHash(this, sizeof(*this), 0x1234567);
 	}
 
-	static TextureSurfaceInfo newZero()
+	static TextureSurfaceDescriptor newZero()
 	{
-		return TextureSurfaceInfo();
+		return TextureSurfaceDescriptor();
 	}
 };
 
 /// A way to identify a volume in 3D textures.
-class TextureVolumeInfo
+class TextureVolumeDescriptor
 {
 public:
 	U32 m_level = 0;
 
-	TextureVolumeInfo() = default;
+	TextureVolumeDescriptor() = default;
 
-	TextureVolumeInfo(const TextureVolumeInfo&) = default;
+	TextureVolumeDescriptor(const TextureVolumeDescriptor&) = default;
 
-	TextureVolumeInfo(U32 level)
+	TextureVolumeDescriptor(U32 level)
 		: m_level(level)
 	{
 	}
 
-	TextureVolumeInfo& operator=(const TextureVolumeInfo&) = default;
+	TextureVolumeDescriptor& operator=(const TextureVolumeDescriptor&) = default;
 };
 
 /// Defines a subset of a texture.
@@ -1035,7 +1035,7 @@ public:
 
 	TextureSubresourceInfo(const TextureSubresourceInfo&) = default;
 
-	constexpr TextureSubresourceInfo(const TextureSurfaceInfo& surf, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
+	constexpr TextureSubresourceInfo(const TextureSurfaceDescriptor& surf, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 		: m_firstMipmap(surf.m_level)
 		, m_mipmapCount(1)
 		, m_firstLayer(surf.m_layer)
@@ -1046,7 +1046,7 @@ public:
 	{
 	}
 
-	constexpr TextureSubresourceInfo(const TextureVolumeInfo& vol, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
+	constexpr TextureSubresourceInfo(const TextureVolumeDescriptor& vol, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone)
 		: m_firstMipmap(vol.m_level)
 		, m_mipmapCount(1)
 		, m_firstLayer(0)

AnKi/Gr/RenderGraph.cpp

@@ -64,10 +64,10 @@ public:
 	U32 m_idx;
 	TextureUsageBit m_usageBefore;
 	TextureUsageBit m_usageAfter;
-	TextureSurfaceInfo m_surface;
+	TextureSurfaceDescriptor m_surface;
 	DepthStencilAspectBit m_dsAspect;
 
-	TextureBarrier(U32 rtIdx, TextureUsageBit usageBefore, TextureUsageBit usageAfter, const TextureSurfaceInfo& surf, DepthStencilAspectBit dsAspect)
+	TextureBarrier(U32 rtIdx, TextureUsageBit usageBefore, TextureUsageBit usageAfter, const TextureSurfaceDescriptor& surf, DepthStencilAspectBit dsAspect)
 		: m_idx(rtIdx)
 		, m_usageBefore(usageBefore)
 		, m_usageAfter(usageAfter)
@@ -766,7 +766,7 @@ void RenderGraph::iterateSurfsOrVolumes(const Texture& tex, const TextureSubreso
 				// Compute surf or vol idx
 				const U32 faceCount = textureTypeIsCube(tex.getTextureType()) ? 6 : 1;
 				const U32 idx = (faceCount * tex.getLayerCount()) * mip + faceCount * layer + face;
-				const TextureSurfaceInfo surf(mip, face, layer);
+				const TextureSurfaceDescriptor surf(mip, face, layer);
 
 				if(!func(idx, surf))
 				{
@@ -787,7 +787,7 @@ void RenderGraph::setTextureBarrier(Batch& batch, const RenderPassDependency& de
 	const TextureUsageBit depUsage = dep.m_texture.m_usage;
 	RT& rt = ctx.m_rts[rtIdx];
 
-	iterateSurfsOrVolumes(*rt.m_texture, dep.m_texture.m_subresource, [&](U32 surfOrVolIdx, const TextureSurfaceInfo& surf) {
+	iterateSurfsOrVolumes(*rt.m_texture, dep.m_texture.m_subresource, [&](U32 surfOrVolIdx, const TextureSurfaceDescriptor& surf) {
 		TextureUsageBit& crntUsage = rt.m_surfOrVolUsages[surfOrVolIdx];
 
 		const Bool skipBarrier = crntUsage == depUsage && !(crntUsage & TextureUsageBit::kAllWrite);

AnKi/Gr/RenderGraph.h

@@ -380,7 +380,7 @@ class RenderTargetInfo
 {
 public:
 	RenderTargetHandle m_handle;
-	TextureSurfaceInfo m_surface;
+	TextureSurfaceDescriptor m_surface;
 	DepthStencilAspectBit m_aspect = DepthStencilAspectBit::kNone; ///< Relevant only for depth stencil textures.
 
 	RenderTargetLoadOperation m_loadOperation = RenderTargetLoadOperation::kDontCare;

AnKi/Gr/TextureView.h

@@ -38,7 +38,7 @@ public:
 	{
 	}
 
-	TextureViewInitInfo(Texture* tex, const TextureSurfaceInfo& surf, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone, CString name = {})
+	TextureViewInitInfo(Texture* tex, const TextureSurfaceDescriptor& surf, DepthStencilAspectBit aspect = DepthStencilAspectBit::kNone, CString name = {})
 		: GrBaseInitInfo(name)
 		, m_texture(tex)
 	{

AnKi/Gr/Vulkan/VkCommandBuffer.cpp

@@ -823,7 +823,7 @@ void CommandBuffer::generateMipmaps2d(TextureView* texView)
 		if(i > 0)
 		{
 			VkImageSubresourceRange range;
-			tex.computeVkImageSubresourceRange(TextureSubresourceInfo(TextureSurfaceInfo(i, face, layer), aspect), range);
+			tex.computeVkImageSubresourceRange(TextureSubresourceInfo(TextureSurfaceDescriptor(i, face, layer), aspect), range);
 
 			self.setImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 								 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, tex.m_imageHandle,
@@ -833,7 +833,7 @@ void CommandBuffer::generateMipmaps2d(TextureView* texView)
 		// Transition destination
 		{
 			VkImageSubresourceRange range;
-			tex.computeVkImageSubresourceRange(TextureSubresourceInfo(TextureSurfaceInfo(i + 1, face, layer), aspect), range);
+			tex.computeVkImageSubresourceRange(TextureSubresourceInfo(TextureSurfaceDescriptor(i + 1, face, layer), aspect), range);
 
 			self.setImageBarrier(VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_PIPELINE_STAGE_TRANSFER_BIT,
 								 VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, tex.m_imageHandle, range);
@@ -928,8 +928,8 @@ void CommandBuffer::copyBufferToTexture(const BufferView& buff, TextureView* tex
 	const Bool is3D = tex.getTextureType() == TextureType::k3D;
 	const VkImageAspectFlags aspect = convertImageAspect(view.getSubresource().m_depthStencilAspect);
 
-	const TextureSurfaceInfo surf(view.getSubresource().m_firstMipmap, view.getSubresource().m_firstFace, view.getSubresource().m_firstLayer);
-	const TextureVolumeInfo vol(view.getSubresource().m_firstMipmap);
+	const TextureSurfaceDescriptor surf(view.getSubresource().m_firstMipmap, view.getSubresource().m_firstFace, view.getSubresource().m_firstLayer);
+	const TextureVolumeDescriptor vol(view.getSubresource().m_firstMipmap);
 
 	// Compute the sizes of the mip
 	const U32 width = tex.getWidth() >> surf.m_level;

AnKi/Gr/Vulkan/VkTexture.h

@@ -109,7 +109,7 @@ public:
 	}
 
 	/// Compute the layer as defined by Vulkan.
-	U32 computeVkArrayLayer(const TextureSurfaceInfo& surf) const
+	U32 computeVkArrayLayer(const TextureSurfaceDescriptor& surf) const
 	{
 		U32 layer = 0;
 		switch(m_texType)
@@ -133,7 +133,7 @@ public:
 		return layer;
 	}
 
-	U32 computeVkArrayLayer([[maybe_unused]] const TextureVolumeInfo& vol) const
+	U32 computeVkArrayLayer([[maybe_unused]] const TextureVolumeDescriptor& vol) const
 	{
 		ANKI_ASSERT(m_texType == TextureType::k3D);
 		return 0;

AnKi/Renderer/DepthDownscale.cpp

@@ -175,12 +175,12 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 			}
 			else
 			{
-				TextureSurfaceInfo subresource;
+				TextureSurfaceDescriptor subresource;
 				subresource.m_level = mip - 1;
 				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, subresource);
 			}
 
-			TextureSurfaceInfo subresource;
+			TextureSurfaceDescriptor subresource;
 			subresource.m_level = mip;
 			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, subresource);
 

AnKi/Renderer/DepthDownscale.h

@@ -18,8 +18,8 @@ namespace anki {
 class DepthDownscale : public RendererObject
 {
 public:
-	static constexpr TextureSubresourceInfo kQuarterInternalResolution = TextureSurfaceInfo(0, 0, 0);
-	static constexpr TextureSubresourceInfo kEighthInternalResolution = TextureSurfaceInfo(1, 0, 0);
+	static constexpr TextureSubresourceInfo kQuarterInternalResolution = TextureSurfaceDescriptor(0, 0, 0);
+	static constexpr TextureSubresourceInfo kEighthInternalResolution = TextureSurfaceDescriptor(1, 0, 0);
 
 	DepthDownscale() = default;
 

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -252,7 +252,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, f, 0));
 				}
 				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllFramebuffer, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
@@ -397,11 +397,11 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 
 				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
 
-				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, f, 0));
+				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, f, 0));
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, f, 0));
 				}
 				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSampledFragment, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 

AnKi/Renderer/ProbeReflections.cpp

@@ -252,7 +252,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, f, 0));
 			}
 
 			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kAllFramebuffer, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
@@ -392,11 +392,11 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			pass.setRenderpassInfo({colorRti});
 
 			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kStorageFragmentRead);
-			pass.newTextureDependency(probeTexture, TextureUsageBit::kFramebufferWrite, TextureSubresourceInfo(TextureSurfaceInfo(0, f, 0)));
+			pass.newTextureDependency(probeTexture, TextureUsageBit::kFramebufferWrite, TextureSubresourceInfo(TextureSurfaceDescriptor(0, f, 0)));
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, f, 0));
 			}
 			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSampledFragment, TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
@@ -519,14 +519,14 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		{
 			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(generateTempPassName("Cube refl: Gen mips", faceIdx));
 
-			TextureSubresourceInfo subresource(TextureSurfaceInfo(0, faceIdx, 0));
+			TextureSubresourceInfo subresource(TextureSurfaceDescriptor(0, faceIdx, 0));
 			subresource.m_mipmapCount = m_lightShading.m_mipCount;
 			pass.newTextureDependency(probeTexture, TextureUsageBit::kGenerateMipmaps, subresource);
 
 			pass.setWork([this, faceIdx, probeTexture](RenderPassWorkContext& rgraphCtx) {
 				ANKI_TRACE_SCOPED_EVENT(ProbeReflections);
 
-				TextureSubresourceInfo subresource(TextureSurfaceInfo(0, faceIdx, 0));
+				TextureSubresourceInfo subresource(TextureSurfaceDescriptor(0, faceIdx, 0));
 				subresource.m_mipmapCount = m_lightShading.m_mipCount;
 
 				Texture* texToBind;

AnKi/Renderer/Renderer.cpp

@@ -482,7 +482,7 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, Text
 		{
 			for(U32 layer = 0; layer < inf.m_layerCount; ++layer)
 			{
-				TextureSurfaceInfo surf(mip, face, layer);
+				TextureSurfaceDescriptor surf(mip, face, layer);
 
 				if(!useCompute)
 				{

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -66,7 +66,7 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kStorageComputeWrite);
 		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt(),
-								   TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0));
+								   TextureUsageBit::kSampledCompute, TextureSurfaceDescriptor(0, 0, 0));
 		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
@@ -90,7 +90,7 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
 		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt(),
-								   TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0));
+								   TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0));
 		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment);
 
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);

AnKi/Resource/ImageResource.cpp

@@ -268,12 +268,12 @@ Error ImageResource::load(LoadingContext& ctx)
 
 			if(ctx.m_texType == TextureType::k3D)
 			{
-				barrier.m_subresource = TextureVolumeInfo(mip);
-				TextureVolumeInfo vol(mip);
+				barrier.m_subresource = TextureVolumeDescriptor(mip);
+				TextureVolumeDescriptor vol(mip);
 			}
 			else
 			{
-				barrier.m_subresource = TextureSurfaceInfo(mip, face, layer);
+				barrier.m_subresource = TextureSurfaceDescriptor(mip, face, layer);
 			}
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
@@ -320,11 +320,11 @@ Error ImageResource::load(LoadingContext& ctx)
 			TextureSubresourceInfo subresource;
 			if(ctx.m_texType == TextureType::k3D)
 			{
-				subresource = TextureSubresourceInfo(TextureVolumeInfo(mip));
+				subresource = TextureSubresourceInfo(TextureVolumeDescriptor(mip));
 			}
 			else
 			{
-				subresource = TextureSubresourceInfo(TextureSurfaceInfo(mip, face, layer));
+				subresource = TextureSubresourceInfo(TextureSurfaceDescriptor(mip, face, layer));
 			}
 
 			TextureViewPtr tmpView = GrManager::getSingleton().newTextureView(TextureViewInitInfo(ctx.m_tex.get(), subresource, "RsrcTmp"));
@@ -345,11 +345,11 @@ Error ImageResource::load(LoadingContext& ctx)
 
 			if(ctx.m_texType == TextureType::k3D)
 			{
-				barrier.m_subresource = TextureVolumeInfo(mip);
+				barrier.m_subresource = TextureVolumeDescriptor(mip);
 			}
 			else
 			{
-				barrier.m_subresource = TextureSurfaceInfo(mip, face, layer);
+				barrier.m_subresource = TextureSurfaceDescriptor(mip, face, layer);
 			}
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});

AnKi/Ui/Font.cpp

@@ -83,7 +83,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	m_imFontAtlas->SetTexID(UiImageId(m_texView));
 
 	// Do the copy
-	constexpr TextureSurfaceInfo surf(0, 0, 0);
+	constexpr TextureSurfaceDescriptor surf(0, 0, 0);
 	CommandBufferInitInfo cmdbInit;
 	cmdbInit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = GrManager::getSingleton().newCommandBuffer(cmdbInit);

Tests/Gr/Gr.cpp

@@ -356,7 +356,7 @@ static void presentBarrierB(CommandBufferPtr cmdb, TexturePtr presentTex)
 }
 
 static void setTextureSurfaceBarrier(CommandBufferPtr& cmdb, TexturePtr tex, TextureUsageBit before, TextureUsageBit after,
-									 const TextureSurfaceInfo& surf)
+									 const TextureSurfaceDescriptor& surf)
 {
 	TextureBarrierInfo barrier;
 	barrier.m_previousUsage = before;
@@ -380,7 +380,7 @@ static void setTextureBarrier(CommandBufferPtr& cmdb, TexturePtr tex, TextureUsa
 }
 
 static void setTextureVolumeBarrier(CommandBufferPtr& cmdb, TexturePtr tex, TextureUsageBit before, TextureUsageBit after,
-									const TextureVolumeInfo& vol)
+									const TextureVolumeDescriptor& vol)
 {
 	TextureBarrierInfo barrier;
 	barrier.m_previousUsage = before;
@@ -737,10 +737,10 @@ void main()
 			CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 			cmdb->setViewport(0, 0, RT_WIDTH, RT_HEIGHT);
-			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
+			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
 			cmdb->beginRenderPass(fb[0].get(), {{TextureUsageBit::kFramebufferWrite}}, {});
 			cmdb->endRenderPass();
-			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
+			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 			cmdb->endRecording();
 			GrManager::getSingleton().submit(cmdb.get());
 		}
@@ -750,7 +750,7 @@ void main()
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		// Draw offscreen
-		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kSampledFragment, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kSampledFragment, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
 		auto vp = VIEWPORTS[(i / 30) % 4];
 		cmdb->setViewport(vp[0], vp[1], vp[2], vp[3]);
 		cmdb->setScissor(vp[0] + SCISSOR_MARGIN, vp[1] + SCISSOR_MARGIN, vp[2] - SCISSOR_MARGIN * 2, vp[3] - SCISSOR_MARGIN * 2);
@@ -764,7 +764,7 @@ void main()
 		cmdb->setViewport(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->setScissor(0, 0, g_win->getWidth(), g_win->getHeight());
 		cmdb->bindShaderProgram(blitProg.get());
-		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 		// cmdb->bindTextureAndSampler(0, 0, texView.get(), sampler.get());
 		presentBarrierA(cmdb, presentTex);
 		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kFramebufferWrite}, {});
@@ -1111,32 +1111,32 @@ ANKI_TEST(Gr, DrawWithTexture)
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
 	// Set barriers
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSampledFragment, TextureUsageBit::kTransferDestination, TextureSurfaceInfo(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSampledFragment, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSampledFragment, TextureUsageBit::kTransferDestination, TextureSurfaceInfo(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSampledFragment, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceInfo(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	TransferGpuAllocatorHandle handle0, handle1, handle2;
-	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceInfo(0, 0, 0, 0), &mip0[0], sizeof(mip0), handle0);
+	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceDescriptor(0, 0, 0, 0), &mip0[0], sizeof(mip0), handle0);
 
-	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceInfo(1, 0, 0, 0), &mip1[0], sizeof(mip1), handle1);
+	UPLOAD_TEX_SURFACE(cmdb, a, TextureSurfaceDescriptor(1, 0, 0, 0), &mip1[0], sizeof(mip1), handle1);
 
-	UPLOAD_TEX_SURFACE(cmdb, b, TextureSurfaceInfo(0, 0, 0, 0), &bmip0[0], sizeof(bmip0), handle2);
+	UPLOAD_TEX_SURFACE(cmdb, b, TextureSurfaceDescriptor(0, 0, 0, 0), &bmip0[0], sizeof(bmip0), handle2);
 
 	// Gen mips
-	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kTransferDestination, TextureUsageBit::kGenerateMipmaps, TextureSurfaceInfo(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kTransferDestination, TextureUsageBit::kGenerateMipmaps, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	cmdb->generateMipmaps2d(g_gr->newTextureView(TextureViewInitInfo(b.get())).get());
 
 	// Set barriers
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	for(U32 i = 0; i < 3; ++i)
 	{
-		setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kGenerateMipmaps, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(i, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kGenerateMipmaps, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(i, 0, 0, 0));
 	}
 
 	FencePtr fence;
@@ -1353,18 +1353,18 @@ static void drawOffscreen(GrManager& gr)
 
 		cmdb->setPolygonOffset(0.0, 0.0);
 
-		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceInfo(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kNone, TextureUsageBit::kAllFramebuffer, TextureSurfaceInfo(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kNone, TextureUsageBit::kFramebufferWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kNone, TextureUsageBit::kAllFramebuffer, TextureSurfaceDescriptor(0, 0, 0, 0));
 		cmdb->beginRenderPass(fb.get(), {{TextureUsageBit::kFramebufferWrite, TextureUsageBit::kFramebufferWrite}}, TextureUsageBit::kAllFramebuffer);
 
 		drawOffscreenDrawcalls(gr, prog, cmdb, TEX_SIZE, indices, verts);
 
 		cmdb->endRenderPass();
 
-		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kAllFramebuffer, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kFramebufferWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kAllFramebuffer, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 		// Draw quad
 		TexturePtr presentTex = gr.acquireNextPresentableTexture();
@@ -1442,22 +1442,22 @@ ANKI_TEST(Gr, ImageLoadStore)
 	CommandBufferInitInfo cmdbinit;
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceInfo(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	ClearValue clear;
 	clear.m_colorf = {{0.0, 1.0, 0.0, 1.0}};
-	TextureViewInitInfo viewInit2(tex.get(), TextureSurfaceInfo(0, 0, 0, 0));
+	TextureViewInitInfo viewInit2(tex.get(), TextureSurfaceDescriptor(0, 0, 0, 0));
 	cmdb->clearTextureView(g_gr->newTextureView(viewInit2).get(), clear);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceInfo(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	clear.m_colorf = {{0.0, 0.0, 1.0, 1.0}};
-	TextureViewInitInfo viewInit3(tex.get(), TextureSurfaceInfo(1, 0, 0, 0));
+	TextureViewInitInfo viewInit3(tex.get(), TextureSurfaceDescriptor(1, 0, 0, 0));
 	cmdb->clearTextureView(g_gr->newTextureView(viewInit3).get(), clear);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kStorageComputeWrite, TextureSurfaceInfo(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kStorageComputeWrite, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	cmdb->endRecording();
 	GrManager::getSingleton().submit(cmdb.get());
@@ -1477,11 +1477,11 @@ ANKI_TEST(Gr, ImageLoadStore)
 		Vec4* col = SET_STORAGE(Vec4*, sizeof(*col), cmdb, 1, 0);
 		*col = Vec4(F32(iterations) / F32(ITERATION_COUNT));
 
-		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kStorageComputeWrite, TextureSurfaceInfo(1, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kStorageComputeWrite, TextureSurfaceDescriptor(1, 0, 0, 0));
 		cmdb->bindShaderProgram(compProg.get());
 		cmdb->bindStorageTexture(0, 0, view.get());
 		cmdb->dispatchCompute(WIDTH / 2, HEIGHT / 2, 1);
-		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kStorageComputeWrite, TextureUsageBit::kSampledFragment, TextureSurfaceInfo(1, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kStorageComputeWrite, TextureUsageBit::kSampledFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 		// Present image
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
@@ -1554,18 +1554,18 @@ ANKI_TEST(Gr, 3DTextures)
 	cmdbinit.m_flags = CommandBufferFlag::kGeneralWork | CommandBufferFlag::kSmallBatch;
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureVolumeInfo(0));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureVolumeDescriptor(0));
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureVolumeInfo(1));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, TextureVolumeDescriptor(1));
 
 	TransferGpuAllocatorHandle handle0, handle1;
-	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeInfo(0), &mip0[0], sizeof(mip0), handle0);
+	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeDescriptor(0), &mip0[0], sizeof(mip0), handle0);
 
-	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeInfo(1), &mip1[0], sizeof(mip1), handle1);
+	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeDescriptor(1), &mip1[0], sizeof(mip1), handle1);
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureVolumeInfo(0));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureVolumeDescriptor(0));
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureVolumeInfo(1));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledFragment, TextureVolumeDescriptor(1));
 
 	FencePtr fence;
 	cmdb->endRecording();
@@ -1685,7 +1685,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSampledFragment);
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
 	{
-		TextureSubresourceInfo subresource(TextureSurfaceInfo(0, faceIdx, 0));
+		TextureSubresourceInfo subresource(TextureSurfaceDescriptor(0, faceIdx, 0));
 
 		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass(String().sprintf("GI lp%u", faceIdx).toCString());
 		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kFramebufferWrite, subresource);
@@ -1702,7 +1702,7 @@ ANKI_TEST(Gr, RenderGraph)
 
 			for(U32 mip = 0; mip < GI_MIP_COUNT; ++mip)
 			{
-				TextureSurfaceInfo surf(mip, faceIdx, 0);
+				TextureSurfaceDescriptor surf(mip, faceIdx, 0);
 				pass.newTextureDependency(giGiLightRt, TextureUsageBit::kGenerateMipmaps, surf);
 			}
 		}
@@ -1928,8 +1928,8 @@ void main()
 	TextureSubresourceInfo subresource;
 	subresource.m_mipmapCount = texInit.m_mipmapCount;
 	setTextureBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination, subresource);
-	cmdb->copyBufferToTexture(BufferView(uploadBuff.get()), g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceInfo(0, 0, 0))).get());
-	cmdb->copyBufferToTexture(BufferView(uploadBuff2.get()), g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceInfo(1, 0, 0))).get());
+	cmdb->copyBufferToTexture(BufferView(uploadBuff.get()), g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceDescriptor(0, 0, 0))).get());
+	cmdb->copyBufferToTexture(BufferView(uploadBuff2.get()), g_gr->newTextureView(TextureViewInitInfo(tex.get(), TextureSurfaceDescriptor(1, 0, 0))).get());
 
 	setTextureBarrier(cmdb, tex, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute, subresource);
 	cmdb->bindShaderProgram(prog.get());
@@ -2185,9 +2185,9 @@ ANKI_TEST(Gr, Bindless)
 	SamplerPtr sampler = gr->newSampler(samplerInit);
 
 	// Create views
-	TextureViewPtr viewA = gr->newTextureView(TextureViewInitInfo(texA, TextureSurfaceInfo()));
-	TextureViewPtr viewB = gr->newTextureView(TextureViewInitInfo(texB, TextureSurfaceInfo()));
-	TextureViewPtr viewC = gr->newTextureView(TextureViewInitInfo(texC, TextureSurfaceInfo()));
+	TextureViewPtr viewA = gr->newTextureView(TextureViewInitInfo(texA, TextureSurfaceDescriptor()));
+	TextureViewPtr viewB = gr->newTextureView(TextureViewInitInfo(texB, TextureSurfaceDescriptor()));
+	TextureViewPtr viewC = gr->newTextureView(TextureViewInitInfo(texC, TextureSurfaceDescriptor()));
 
 	// Create result buffer
 	BufferPtr resBuff =
@@ -2231,26 +2231,26 @@ void main()
 	CommandBufferPtr cmdb = gr->newCommandBuffer(cinit);
 
 	setTextureSurfaceBarrier(cmdb, texA, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
-								   TextureSurfaceInfo());
+								   TextureSurfaceDescriptor());
 	setTextureSurfaceBarrier(cmdb, texB, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
-								   TextureSurfaceInfo());
+								   TextureSurfaceDescriptor());
 	setTextureSurfaceBarrier(cmdb, texC, TextureUsageBit::kNone, TextureUsageBit::kTransferDestination,
-								   TextureSurfaceInfo());
+								   TextureSurfaceDescriptor());
 
 	TransferGpuAllocatorHandle handle0, handle1, handle2;
 	const UVec4 mip0 = UVec4(1, 2, 3, 4);
-	UPLOAD_TEX_SURFACE(cmdb, texA, TextureSurfaceInfo(0, 0, 0, 0), &mip0[0], sizeof(mip0), handle0);
+	UPLOAD_TEX_SURFACE(cmdb, texA, TextureSurfaceDescriptor(0, 0, 0, 0), &mip0[0], sizeof(mip0), handle0);
 	const UVec4 mip1 = UVec4(10, 20, 30, 40);
-	UPLOAD_TEX_SURFACE(cmdb, texB, TextureSurfaceInfo(0, 0, 0, 0), &mip1[0], sizeof(mip1), handle1);
+	UPLOAD_TEX_SURFACE(cmdb, texB, TextureSurfaceDescriptor(0, 0, 0, 0), &mip1[0], sizeof(mip1), handle1);
 	const Vec4 mip2 = Vec4(2.2f, 3.3f, 4.4f, 5.5f);
-	UPLOAD_TEX_SURFACE(cmdb, texC, TextureSurfaceInfo(0, 0, 0, 0), &mip2[0], sizeof(mip2), handle2);
+	UPLOAD_TEX_SURFACE(cmdb, texC, TextureSurfaceDescriptor(0, 0, 0, 0), &mip2[0], sizeof(mip2), handle2);
 
 	setTextureSurfaceBarrier(cmdb, texA, TextureUsageBit::kTransferDestination, TextureUsageBit::kStorageComputeRead,
-								   TextureSurfaceInfo());
+								   TextureSurfaceDescriptor());
 	setTextureSurfaceBarrier(cmdb, texB, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute,
-								   TextureSurfaceInfo());
+								   TextureSurfaceDescriptor());
 	setTextureSurfaceBarrier(cmdb, texC, TextureUsageBit::kTransferDestination, TextureUsageBit::kSampledCompute,
-								   TextureSurfaceInfo());
+								   TextureSurfaceDescriptor());
 
 	cmdb->bindStorageBuffer(1, 0, resBuff, 0, kMaxPtrSize);
 	cmdb->bindSampler(1, 1, sampler);