More refactoring

AnKi/Gr/BackendCommon/GraphicsStateTracker.h

@@ -342,9 +342,9 @@ public:
 			}
 #endif
 
-			if(m_staticState.m_misc.m_colorRtMask != refl.m_fragment.m_colorAttachmentWritemask)
+			if(m_staticState.m_misc.m_colorRtMask != refl.m_pixel.m_colorRenderTargetWritemask)
 			{
-				m_staticState.m_misc.m_colorRtMask = refl.m_fragment.m_colorAttachmentWritemask;
+				m_staticState.m_misc.m_colorRtMask = refl.m_pixel.m_colorRenderTargetWritemask;
 				m_hashes.m_misc = 0;
 			}
 

AnKi/Gr/Common.cpp

@@ -173,8 +173,8 @@ Error ShaderReflection::linkShaderReflection(const ShaderReflection& a, const Sh
 		(a.m_vertex.m_vertexAttributeMask.getAnySet()) ? a.m_vertex.m_vkVertexAttributeLocations : b.m_vertex.m_vkVertexAttributeLocations;
 	c.m_vertex.m_vertexAttributeMask = a.m_vertex.m_vertexAttributeMask | b.m_vertex.m_vertexAttributeMask;
 
-	c.m_fragment.m_colorAttachmentWritemask = a.m_fragment.m_colorAttachmentWritemask | b.m_fragment.m_colorAttachmentWritemask;
-	c.m_fragment.m_discards = a.m_fragment.m_discards || b.m_fragment.m_discards;
+	c.m_pixel.m_colorRenderTargetWritemask = a.m_pixel.m_colorRenderTargetWritemask | b.m_pixel.m_colorRenderTargetWritemask;
+	c.m_pixel.m_discards = a.m_pixel.m_discards || b.m_pixel.m_discards;
 
 	c_ = c;
 	return Error::kNone;

AnKi/Gr/Common.h

@@ -470,12 +470,12 @@ enum class TextureUsageBit : U32
 	kNone = 0,
 
 	kSrvGeometry = 1 << 0,
-	kSrvFragment = 1 << 1,
+	kSrvPixel = 1 << 1,
 	kSrvCompute = 1 << 2,
 	kSrvTraceRays = 1 << 3,
 
 	kUavGeometry = 1 << 4,
-	kUavFragment = 1 << 5,
+	kUavPixel = 1 << 5,
 	kUavCompute = 1 << 6,
 	kUavTraceRays = 1 << 7,
 
@@ -488,13 +488,13 @@ enum class TextureUsageBit : U32
 	kPresent = 1 << 12,
 
 	// Derived
-	kAllSrv = kSrvGeometry | kSrvFragment | kSrvCompute | kSrvTraceRays,
-	kAllUav = kUavGeometry | kUavFragment | kUavCompute | kUavTraceRays,
+	kAllSrv = kSrvGeometry | kSrvPixel | kSrvCompute | kSrvTraceRays,
+	kAllUav = kUavGeometry | kUavPixel | kUavCompute | kUavTraceRays,
 	kAllRtvDsv = kRtvDsvRead | kRtvDsvWrite,
 
 	kAllGeometry = kSrvGeometry | kUavGeometry,
-	kAllFragment = kSrvFragment | kUavFragment,
-	kAllGraphics = kAllGeometry | kAllFragment | kRtvDsvRead | kRtvDsvWrite | kShadingRate,
+	kAllPixel = kSrvPixel | kUavPixel,
+	kAllGraphics = kAllGeometry | kAllPixel | kRtvDsvRead | kRtvDsvWrite | kShadingRate,
 	kAllCompute = kSrvCompute | kUavCompute,
 	kAllTransfer = kCopyDestination,
 
@@ -528,12 +528,12 @@ enum class SamplingAddressing : U8
 enum class ShaderType : U16
 {
 	kVertex,
-	kTessellationControl,
-	kTessellationEvaluation,
+	kHull,
+	kDomain,
 	kGeometry,
-	kTask,
+	kAmplification,
 	kMesh,
-	kFragment,
+	kPixel,
 	kCompute,
 	kRayGen,
 	kAnyHit,
@@ -547,7 +547,7 @@ enum class ShaderType : U16
 	kFirst = 0,
 	kLast = kCount - 1,
 	kFirstGraphics = kVertex,
-	kLastGraphics = kFragment,
+	kLastGraphics = kPixel,
 	kFirstRayTracing = kRayGen,
 	kLastRayTracing = kCallable,
 };
@@ -556,12 +556,12 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderType)
 enum class ShaderTypeBit : U16
 {
 	kVertex = 1 << 0,
-	kTessellationControl = 1 << 1,
-	kTessellationEvaluation = 1 << 2,
+	kHull = 1 << 1,
+	kDomain = 1 << 2,
 	kGeometry = 1 << 3,
-	kTask = 1 << 4,
+	kAmplification = 1 << 4,
 	kMesh = 1 << 5,
-	kFragment = 1 << 6,
+	kPixel = 1 << 6,
 	kCompute = 1 << 7,
 	kRayGen = 1 << 8,
 	kAnyHit = 1 << 9,
@@ -572,9 +572,9 @@ enum class ShaderTypeBit : U16
 	kWorkGraph = 1 << 14,
 
 	kNone = 0,
-	kAllGraphics = kVertex | kTessellationControl | kTessellationEvaluation | kGeometry | kTask | kMesh | kFragment,
-	kAllLegacyGeometry = kVertex | kTessellationControl | kTessellationEvaluation | kGeometry,
-	kAllModernGeometry = kTask | kMesh,
+	kAllGraphics = kVertex | kHull | kDomain | kGeometry | kAmplification | kMesh | kPixel,
+	kAllLegacyGeometry = kVertex | kHull | kDomain | kGeometry,
+	kAllModernGeometry = kAmplification | kMesh,
 	kAllRayTracing = kRayGen | kAnyHit | kClosestHit | kMiss | kIntersection | kCallable,
 	kAllHit = kAnyHit | kClosestHit,
 	kAll = kAllGraphics | kCompute | kAllRayTracing | kWorkGraph,
@@ -681,7 +681,7 @@ enum class RenderTargetStoreOperation : U8
 };
 
 /// Buffer usage modes.
-/// The graphics work consists of the following pipes: indirect, geometry (all programmable and fixed function geometry stages) and finaly fragment.
+/// The graphics work consists of the following pipes: indirect, geometry (all programmable and fixed function geometry stages) and finaly pixel.
 /// The compute from the consists of the following: indirect and compute.
 /// The trace rays from the: indirect and trace_rays
 /// !!WARNING!! If you change this remember to change PrivateBufferUsageBit.
@@ -690,17 +690,17 @@ enum class BufferUsageBit : U64
 	kNone = 0,
 
 	kConstantGeometry = 1ull << 0ull,
-	kConstantFragment = 1ull << 1ull,
+	kConstantPixel = 1ull << 1ull,
 	kConstantCompute = 1ull << 2ull,
 	kConstantTraceRays = 1ull << 3ull,
 
 	kSrvGeometry = 1ull << 4ull,
-	kSrvFragment = 1ull << 5ull,
+	kSrvPixel = 1ull << 5ull,
 	kSrvCompute = 1ull << 6ull,
 	kSrvTraceRays = 1ull << 7ull,
 
 	kUavGeometry = 1ull << 8ull,
-	kUavFragment = 1ull << 9ull,
+	kUavPixel = 1ull << 9ull,
 	kUavCompute = 1ull << 10ull,
 	kUavTraceRays = 1ull << 11ull,
 
@@ -719,15 +719,15 @@ enum class BufferUsageBit : U64
 	kAccelerationStructureBuildScratch = 1ull << 21ull, ///< Used in buildAccelerationStructureXXX commands.
 
 	// Derived
-	kAllConstant = kConstantGeometry | kConstantFragment | kConstantCompute | kConstantTraceRays,
-	kAllSrv = kSrvGeometry | kSrvFragment | kSrvCompute | kSrvTraceRays,
-	kAllUav = kUavGeometry | kUavFragment | kUavCompute | kUavTraceRays,
+	kAllConstant = kConstantGeometry | kConstantPixel | kConstantCompute | kConstantTraceRays,
+	kAllSrv = kSrvGeometry | kSrvPixel | kSrvCompute | kSrvTraceRays,
+	kAllUav = kUavGeometry | kUavPixel | kUavCompute | kUavTraceRays,
 	kAllIndirect = kIndirectCompute | kIndirectDraw | kIndirectTraceRays,
 	kAllCopy = kCopySource | kCopyDestination,
 
 	kAllGeometry = kConstantGeometry | kSrvGeometry | kUavGeometry | kIndex | kVertex,
-	kAllFragment = kConstantFragment | kSrvFragment | kUavFragment,
-	kAllGraphics = kAllGeometry | kAllFragment | kIndirectDraw,
+	kAllPixel = kConstantPixel | kSrvPixel | kUavPixel,
+	kAllGraphics = kAllGeometry | kAllPixel | kIndirectDraw,
 	kAllCompute = kConstantCompute | kSrvCompute | kUavCompute | kIndirectCompute,
 	kAllTraceRays = kConstantTraceRays | kSrvTraceRays | kUavTraceRays | kIndirectTraceRays | kShaderBindingTable,
 
@@ -778,14 +778,14 @@ enum class AccelerationStructureUsageBit : U8
 	kNone = 0,
 	kBuild = 1 << 0,
 	kAttach = 1 << 1, ///< Attached to a TLAS. Only for BLAS.
-	kGeometryRead = 1 << 2,
-	kFragmentRead = 1 << 3,
-	kComputeRead = 1 << 4,
-	kTraceRaysRead = 1 << 5,
+	kGeometrySrv = 1 << 2,
+	kPixelSrv = 1 << 3,
+	kComputeSrv = 1 << 4,
+	kTraceRaysSrv = 1 << 5,
 
 	// Derived
-	kAllGraphics = kGeometryRead | kFragmentRead,
-	kAllRead = kAttach | kGeometryRead | kFragmentRead | kComputeRead | kTraceRaysRead,
+	kAllGraphics = kGeometrySrv | kPixelSrv,
+	kAllRead = kAttach | kGeometrySrv | kPixelSrv | kComputeSrv | kTraceRaysSrv,
 	kAllWrite = kBuild
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(AccelerationStructureUsageBit)
@@ -998,10 +998,10 @@ public:
 	class
 	{
 	public:
-		BitSet<kMaxColorRenderTargets, U8> m_colorAttachmentWritemask = {false};
+		BitSet<kMaxColorRenderTargets, U8> m_colorRenderTargetWritemask = {false};
 
 		Bool m_discards = false;
-	} m_fragment;
+	} m_pixel;
 
 	ShaderReflection()
 	{
@@ -1016,10 +1016,10 @@ public:
 			ANKI_ASSERT(!m_vertex.m_vertexAttributeMask.get(semantic) || m_vertex.m_vkVertexAttributeLocations[semantic] != kMaxU8);
 		}
 
-		const U32 attachmentCount = m_fragment.m_colorAttachmentWritemask.getSetBitCount();
+		const U32 attachmentCount = m_pixel.m_colorRenderTargetWritemask.getSetBitCount();
 		for(U32 i = 0; i < attachmentCount; ++i)
 		{
-			ANKI_ASSERT(m_fragment.m_colorAttachmentWritemask.get(i) && "Should write to all attachments");
+			ANKI_ASSERT(m_pixel.m_colorRenderTargetWritemask.get(i) && "Should write to all attachments");
 		}
 	}
 

AnKi/Gr/D3D/D3DBuffer.cpp

@@ -210,7 +210,7 @@ D3D12_BARRIER_SYNC BufferImpl::computeSync(BufferUsageBit usage) const
 		sync |= D3D12_BARRIER_SYNC_VERTEX_SHADING;
 	}
 
-	if(!!(usage & BufferUsageBit::kAllFragment))
+	if(!!(usage & BufferUsageBit::kAllPixel))
 	{
 		sync |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 	}

AnKi/Gr/D3D/D3DGraphicsState.cpp

@@ -256,10 +256,10 @@ void GraphicsPipelineFactory::flushState(GraphicsStateTracker& state, D3D12Graph
 	desc.PrimitiveTopologyType = convertPrimitiveTopology(staticState.m_ia.m_topology);
 	ANKI_SET_IR(VS, kVertex)
 	ANKI_SET_IR(GS, kGeometry)
-	ANKI_SET_IR(HS, kTessellationControl)
-	ANKI_SET_IR(DS, kTessellationEvaluation)
-	ANKI_SET_IR(PS, kFragment)
-	ANKI_SET_IR(AS, kTask)
+	ANKI_SET_IR(HS, kHull)
+	ANKI_SET_IR(DS, kDomain)
+	ANKI_SET_IR(PS, kPixel)
+	ANKI_SET_IR(AS, kAmplification)
 	ANKI_SET_IR(MS, kMesh)
 	desc.BlendState = CD3DX12_BLEND_DESC(blendDesc);
 	desc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC2(dsDesc);

AnKi/Gr/D3D/D3DShader.cpp

@@ -27,7 +27,7 @@ Error ShaderImpl::init(const ShaderInitInfo& inf)
 {
 	m_shaderType = inf.m_shaderType;
 	m_shaderBinarySize = U32(inf.m_binary.getSizeInBytes());
-	m_hasDiscard = inf.m_reflection.m_fragment.m_discards;
+	m_hasDiscard = inf.m_reflection.m_pixel.m_discards;
 	m_reflection = inf.m_reflection;
 	m_reflection.validate();
 

AnKi/Gr/D3D/D3DShaderProgram.cpp

@@ -53,7 +53,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 	{
 		m_shaders.emplaceBack(inf.m_computeShader);
 	}
-	else if(inf.m_graphicsShaders[ShaderType::kFragment])
+	else if(inf.m_graphicsShaders[ShaderType::kPixel])
 	{
 		for(Shader* s : inf.m_graphicsShaders)
 		{

AnKi/Gr/D3D/D3DShaderProgram.h

@@ -26,7 +26,7 @@ public:
 	{
 	public:
 		GraphicsPipelineFactory* m_pipelineFactory = nullptr;
-		Array<D3D12_SHADER_BYTECODE, U32(ShaderType::kFragment - ShaderType::kVertex) + 1> m_shaderCreateInfos = {};
+		Array<D3D12_SHADER_BYTECODE, U32(ShaderType::kPixel - ShaderType::kVertex) + 1> m_shaderCreateInfos = {};
 	} m_graphics;
 
 	class

AnKi/Gr/D3D/D3DTexture.cpp

@@ -587,7 +587,7 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, D3D12_BARRIER_SYNC&
 		{
 			// Reading in the renderpass and sampling at the same time
 
-			if(!!(usage & (TextureUsageBit::kSrvGeometry | TextureUsageBit::kSrvFragment)))
+			if(!!(usage & (TextureUsageBit::kSrvGeometry | TextureUsageBit::kSrvPixel)))
 			{
 				stages |= D3D12_BARRIER_SYNC_DRAW;
 			}
@@ -613,7 +613,7 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, D3D12_BARRIER_SYNC&
 				stages |= D3D12_BARRIER_SYNC_VERTEX_SHADING;
 			}
 
-			if(!!(usage & TextureUsageBit::kSrvFragment))
+			if(!!(usage & TextureUsageBit::kSrvPixel))
 			{
 				stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			}
@@ -652,13 +652,13 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, D3D12_BARRIER_SYNC&
 			accesses |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
 		}
 
-		if(!!(usage & TextureUsageBit::kSrvFragment))
+		if(!!(usage & TextureUsageBit::kSrvPixel))
 		{
 			stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
 		}
 
-		if(!!(usage & TextureUsageBit::kUavFragment))
+		if(!!(usage & TextureUsageBit::kUavPixel))
 		{
 			stages |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
 			accesses |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;

AnKi/Gr/RenderGraph.cpp

@@ -1414,7 +1414,7 @@ StringRaii RenderGraph::bufferUsageToStr(StackMemoryPool& pool, BufferUsageBit u
 		}
 
 	ANKI_BUFF_USAGE(kConstantGeometry);
-	ANKI_BUFF_USAGE(kConstantFragment);
+	ANKI_BUFF_USAGE(kConstantPixel);
 	ANKI_BUFF_USAGE(kConstantCompute);
 	ANKI_BUFF_USAGE(kConstantTraceRays);
 	ANKI_BUFF_USAGE(kStorageGeometryRead);

AnKi/Gr/Shader.h

@@ -109,10 +109,10 @@ public:
 		return m_shaderBinarySize;
 	}
 
-	/// Fragment shader had a discard.
+	/// Pixel shader had a discard.
 	U32 hasDiscard() const
 	{
-		ANKI_ASSERT(m_shaderType == ShaderType::kFragment);
+		ANKI_ASSERT(m_shaderType == ShaderType::kPixel);
 		return m_hasDiscard;
 	}
 

AnKi/Gr/ShaderProgram.cpp

@@ -24,7 +24,7 @@ Bool ShaderProgramInitInfo::isValid() const
 
 	if(!!graphicsMask)
 	{
-		if(!(graphicsMask & ShaderTypeBit::kFragment))
+		if(!(graphicsMask & ShaderTypeBit::kPixel))
 		{
 			return false;
 		}

AnKi/Gr/ShaderProgram.h

@@ -99,11 +99,11 @@ public:
 		return m_shaderBinarySizes[type];
 	}
 
-	/// The fragment shader of the program has a discard.
+	/// The pixel shader of the program has a discard.
 	Bool hasDiscard() const
 	{
-		ANKI_ASSERT(!!(m_shaderTypes & ShaderTypeBit::kFragment));
-		return m_refl.m_fragment.m_discards;
+		ANKI_ASSERT(!!(m_shaderTypes & ShaderTypeBit::kPixel));
+		return m_refl.m_pixel.m_discards;
 	}
 
 	const ShaderReflection& getReflection() const

AnKi/Gr/Vulkan/VkAccelerationStructure.cpp

@@ -238,26 +238,26 @@ VkMemoryBarrier AccelerationStructureImpl::computeBarrierInfo(AccelerationStruct
 		barrier.srcAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::kGeometryRead))
+	if(!!(before & AccelerationStructureUsageBit::kGeometrySrv))
 	{
 		srcStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 		barrier.srcAccessMask |= VK_ACCESS_MEMORY_READ_BIT; // READ_BIT is the only viable solution by elimination
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::kFragmentRead))
+	if(!!(before & AccelerationStructureUsageBit::kPixelSrv))
 	{
 		srcStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		barrier.srcAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::kComputeRead))
+	if(!!(before & AccelerationStructureUsageBit::kComputeSrv))
 	{
 		srcStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		barrier.srcAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(before & AccelerationStructureUsageBit::kTraceRaysRead))
+	if(!!(before & AccelerationStructureUsageBit::kTraceRaysSrv))
 	{
 		srcStages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		barrier.srcAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
@@ -278,26 +278,26 @@ VkMemoryBarrier AccelerationStructureImpl::computeBarrierInfo(AccelerationStruct
 		barrier.dstAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::kGeometryRead))
+	if(!!(after & AccelerationStructureUsageBit::kGeometrySrv))
 	{
 		dstStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 					 | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 		barrier.dstAccessMask |= VK_ACCESS_MEMORY_READ_BIT; // READ_BIT is the only viable solution by elimination
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::kFragmentRead))
+	if(!!(after & AccelerationStructureUsageBit::kPixelSrv))
 	{
 		dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		barrier.dstAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::kComputeRead))
+	if(!!(after & AccelerationStructureUsageBit::kComputeSrv))
 	{
 		dstStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		barrier.dstAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
 	}
 
-	if(!!(after & AccelerationStructureUsageBit::kTraceRaysRead))
+	if(!!(after & AccelerationStructureUsageBit::kTraceRaysSrv))
 	{
 		dstStages |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
 		barrier.dstAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;

AnKi/Gr/Vulkan/VkBuffer.cpp

@@ -323,7 +323,7 @@ VkPipelineStageFlags BufferImpl::computePplineStage(BufferUsageBit usage)
 		}
 	}
 
-	if(!!(usage & BufferUsageBit::kAllFragment))
+	if(!!(usage & BufferUsageBit::kAllPixel))
 	{
 		stageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 	}

AnKi/Gr/Vulkan/VkCommon.cpp

@@ -487,12 +487,12 @@ VkShaderStageFlags convertShaderTypeBit(ShaderTypeBit bit)
 		out |= VK_SHADER_STAGE_VERTEX_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::kTessellationControl))
+	if(!!(bit & ShaderTypeBit::kHull))
 	{
 		out |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::kTessellationEvaluation))
+	if(!!(bit & ShaderTypeBit::kDomain))
 	{
 		out |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
 	}
@@ -502,7 +502,7 @@ VkShaderStageFlags convertShaderTypeBit(ShaderTypeBit bit)
 		out |= VK_SHADER_STAGE_GEOMETRY_BIT;
 	}
 
-	if(!!(bit & ShaderTypeBit::kTask))
+	if(!!(bit & ShaderTypeBit::kAmplification))
 	{
 		out |= VK_SHADER_STAGE_TASK_BIT_EXT;
 	}
@@ -512,7 +512,7 @@ VkShaderStageFlags convertShaderTypeBit(ShaderTypeBit bit)
 		out |= VK_SHADER_STAGE_MESH_BIT_EXT;
 	}
 
-	if(!!(bit & ShaderTypeBit::kFragment))
+	if(!!(bit & ShaderTypeBit::kPixel))
 	{
 		out |= VK_SHADER_STAGE_FRAGMENT_BIT;
 	}

AnKi/Gr/Vulkan/VkShader.cpp

@@ -36,7 +36,7 @@ Error ShaderImpl::init(const ShaderInitInfo& inf)
 	inf.validate();
 	ANKI_ASSERT((inf.m_binary.getSize() % sizeof(U32)) == 0);
 	m_shaderType = inf.m_shaderType;
-	m_hasDiscard = inf.m_reflection.m_fragment.m_discards;
+	m_hasDiscard = inf.m_reflection.m_pixel.m_discards;
 	m_shaderBinarySize = U32(inf.m_binary.getSizeInBytes());
 	m_reflection = inf.m_reflection;
 	m_reflection.validate();

AnKi/Gr/Vulkan/VkShaderProgram.cpp

@@ -165,7 +165,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 	{
 		m_shaders.emplaceBack(inf.m_computeShader);
 	}
-	else if(inf.m_graphicsShaders[ShaderType::kFragment])
+	else if(inf.m_graphicsShaders[ShaderType::kPixel])
 	{
 		for(Shader* s : inf.m_graphicsShaders)
 		{

AnKi/Gr/Vulkan/VkShaderProgram.h

@@ -97,7 +97,7 @@ private:
 	class
 	{
 	public:
-		Array<VkPipelineShaderStageCreateInfo, U32(ShaderType::kFragment - ShaderType::kVertex) + 1> m_shaderCreateInfos = {};
+		Array<VkPipelineShaderStageCreateInfo, U32(ShaderType::kPixel - ShaderType::kVertex) + 1> m_shaderCreateInfos = {};
 		U32 m_shaderCreateInfoCount = 0;
 		GraphicsPipelineFactory* m_pplineFactory = nullptr;
 	} m_graphics;

AnKi/Gr/Vulkan/VkTexture.cpp

@@ -320,13 +320,13 @@ void TextureImpl::computeBarrierInfo(TextureUsageBit usage, VkPipelineStageFlags
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kSrvFragment))
+	if(!!(usage & TextureUsageBit::kSrvPixel))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_READ_BIT;
 	}
 
-	if(!!(usage & TextureUsageBit::kUavFragment))
+	if(!!(usage & TextureUsageBit::kUavPixel))
 	{
 		stages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 		accesses |= VK_ACCESS_SHADER_WRITE_BIT;

AnKi/Renderer/Bloom.cpp

@@ -98,7 +98,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
 			rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_exposureRt)});
 
-			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSrvFragment, inputTexSubresource);
+			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSrvPixel, inputTexSubresource);
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kRtvDsvWrite);
 
 			prpass = &rpass;
@@ -156,7 +156,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPass& rpass = rgraph.newGraphicsRenderPass("Bloom Upscale");
 			rpass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_upscaleRt)});
 
-			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSrvFragment);
+			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kSrvPixel);
 			rpass.newTextureDependency(m_runCtx.m_upscaleRt, TextureUsageBit::kRtvDsvWrite);
 
 			prpass = &rpass;

AnKi/Renderer/Dbg.cpp

@@ -255,7 +255,7 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 	pass.setRenderpassInfo({colorRti}, &depthRti);
 
 	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment | TextureUsageBit::kRtvDsvRead);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvPixel | TextureUsageBit::kRtvDsvRead);
 
 	BufferView indicesBuff;
 	BufferHandle dep;

AnKi/Renderer/DepthDownscale.cpp

@@ -153,11 +153,11 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 			if(mip == 0)
 			{
-				pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment);
+				pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvPixel);
 			}
 			else
 			{
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(mip - 1, 0, 0));
+				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSrvPixel, TextureSubresourceDesc::surface(mip - 1, 0, 0));
 			}
 
 			pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(mip, 0, 0));

AnKi/Renderer/DownscaleBlur.cpp

@@ -35,7 +35,7 @@ Error DownscaleBlur::initInternal()
 
 	// Create the miped texture
 	TextureInitInfo texinit = getRenderer().create2DRenderTargetDescription(rez.x(), rez.y(), getRenderer().getHdrFormat(), "DownscaleBlur");
-	texinit.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute;
+	texinit.m_usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kSrvCompute;
 	if(preferCompute)
 	{
 		texinit.m_usage |= TextureUsageBit::kUavCompute;
@@ -87,7 +87,7 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 			ppass = &pass;
 		}
 
-		const TextureUsageBit readUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kSrvCompute : TextureUsageBit::kSrvFragment;
+		const TextureUsageBit readUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kSrvCompute : TextureUsageBit::kSrvPixel;
 		const TextureUsageBit writeUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kUavCompute : TextureUsageBit::kRtvDsvWrite;
 
 		if(i > 0)

AnKi/Renderer/FinalComposite.cpp

@@ -82,13 +82,13 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 
 	if(g_dbgCVar.get())
 	{
-		pass.newTextureDependency(getRenderer().getDbg().getRt(), TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(getRenderer().getDbg().getRt(), TextureUsageBit::kSrvPixel);
 	}
 
-	pass.newTextureDependency(getRenderer().getScale().getTonemappedRt(), TextureUsageBit::kSrvFragment);
-	pass.newTextureDependency(getRenderer().getBloom().getRt(), TextureUsageBit::kSrvFragment);
-	pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSrvFragment);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment);
+	pass.newTextureDependency(getRenderer().getScale().getTonemappedRt(), TextureUsageBit::kSrvPixel);
+	pass.newTextureDependency(getRenderer().getBloom().getRt(), TextureUsageBit::kSrvPixel);
+	pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSrvPixel);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvPixel);
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
 	ShaderProgramPtr debugProgram;
@@ -99,7 +99,7 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 		{
 			if(handle.isValid())
 			{
-				pass.newTextureDependency(handle, TextureUsageBit::kSrvFragment);
+				pass.newTextureDependency(handle, TextureUsageBit::kSrvPixel);
 			}
 		}
 	}

AnKi/Renderer/ForwardShading.cpp

@@ -99,8 +99,8 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 void ForwardShading::setDependencies(GraphicsRenderPass& pass)
 {
-	pass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSrvFragment, DepthDownscale::kQuarterInternalResolution);
-	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSrvFragment);
+	pass.newTextureDependency(getRenderer().getDepthDownscale().getRt(), TextureUsageBit::kSrvPixel, DepthDownscale::kQuarterInternalResolution);
+	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSrvPixel);
 
 	if(getRenderer().getLensFlare().getIndirectDrawBuffer().isValid())
 	{

AnKi/Renderer/GBuffer.cpp

@@ -52,7 +52,7 @@ Error GBuffer::initInternal()
 			getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
 													   getRenderer().getDepthNoStencilFormat(), usage, depthRtNames[i]);
 
-		m_depthRts[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+		m_depthRts[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
 	}
 
 	static constexpr Array<const char*, kGBufferColorRenderTargetCount> rtNames = {{"GBuffer rt0", "GBuffer rt1", "GBuffer rt2", "GBuffer rt3"}};
@@ -96,7 +96,7 @@ void GBuffer::importRenderTargets(RenderingContext& ctx)
 	{
 		m_runCtx.m_crntFrameDepthRt = rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1].get(), TextureUsageBit::kNone);
 		m_runCtx.m_prevFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1].get(), TextureUsageBit::kSrvFragment);
+			rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1].get(), TextureUsageBit::kSrvPixel);
 
 		m_runCtx.m_hzbRt = rgraph.importRenderTarget(m_hzbRt.get(), TextureUsageBit::kSrvCompute);
 	}
@@ -152,7 +152,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 
 		pass.newTextureDependency(m_runCtx.m_crntFrameDepthRt, rtUsage);
 
-		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kSrvGeometry | BufferUsageBit::kSrvFragment);
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kSrvGeometry | BufferUsageBit::kSrvPixel);
 
 		// Only add one depedency to the GPU visibility. No need to track all buffers
 		if(visOut.containsDrawcalls())

AnKi/Renderer/GBufferPost.cpp

@@ -82,11 +82,11 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), TextureUsageBit::kAllRtvDsv);
 	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), TextureUsageBit::kAllRtvDsv);
-	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment);
+	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvPixel);
 
-	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvFragment);
+	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvPixel);
 	rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kDecal),
-							  BufferUsageBit::kSrvFragment);
+							  BufferUsageBit::kSrvPixel);
 }
 
 } // end namespace anki

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -358,25 +358,25 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 				colorRti.m_subresource.m_face = f;
 				pass.setRenderpassInfo({colorRti});
 
-				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kSrvFragment);
+				pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kSrvPixel);
 
 				pass.newTextureDependency(lightShadingRt, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(0, f, 0));
 
 				for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 				{
-					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(0, f, 0));
+					pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvPixel, TextureSubresourceDesc::surface(0, f, 0));
 				}
-				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSrvFragment,
+				pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSrvPixel,
 										  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
 
 				if(shadowsRt.isValid())
 				{
-					pass.newTextureDependency(shadowsRt, TextureUsageBit::kSrvFragment);
+					pass.newTextureDependency(shadowsRt, TextureUsageBit::kSrvPixel);
 				}
 
 				if(getRenderer().getSky().isEnabled())
 				{
-					pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSrvFragment);
+					pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSrvPixel);
 				}
 
 				pass.setWork([this, visibleLightsBuffer = lightVis.m_visiblesBuffer, viewProjMat = frustum.getViewProjectionMatrix(), cellCenter,

AnKi/Renderer/LightShading.cpp

@@ -274,7 +274,7 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 						   (enableVrs) ? getRenderer().getVrsSriGeneration().getSriTexelDimension() : 0,
 						   (enableVrs) ? getRenderer().getVrsSriGeneration().getSriTexelDimension() : 0);
 
-	const TextureUsageBit readUsage = TextureUsageBit::kSrvFragment;
+	const TextureUsageBit readUsage = TextureUsageBit::kSrvPixel;
 
 	// All
 	if(enableVrs)
@@ -287,11 +287,11 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), readUsage);
 	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), readUsage);
 	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), readUsage);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvFragment | TextureUsageBit::kRtvDsvRead);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSrvPixel | TextureUsageBit::kRtvDsvRead);
 	pass.newTextureDependency(getRenderer().getShadowmapsResolve().getRt(), readUsage);
-	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvFragment);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvPixel);
 	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-							 BufferUsageBit::kSrvFragment);
+							 BufferUsageBit::kSrvPixel);
 	pass.newTextureDependency(getRenderer().getSsao().getRt(), readUsage);
 	pass.newTextureDependency(getRenderer().getSsr().getRt(), readUsage);
 

AnKi/Renderer/MainRenderer.cpp

@@ -125,7 +125,7 @@ Error MainRenderer::render(Texture* presentTex)
 		});
 
 		pass.newTextureDependency(presentRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(ctx.m_outRenderTarget, TextureUsageBit::kSrvPixel);
 	}
 
 	// Create a dummy pass to transition the presentable image to present

AnKi/Renderer/MotionVectors.cpp

@@ -60,7 +60,7 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 		GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("MotionVectors");
 		pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_motionVectorsRtHandle)});
 
-		readUsage = TextureUsageBit::kSrvFragment;
+		readUsage = TextureUsageBit::kSrvPixel;
 		writeUsage = TextureUsageBit::kRtvDsvWrite;
 		ppass = &pass;
 	}

AnKi/Renderer/ProbeReflections.cpp

@@ -354,23 +354,23 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 			colorRti.m_loadOperation = RenderTargetLoadOperation::kClear;
 			pass.setRenderpassInfo({colorRti});
 
-			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kSrvFragment);
+			pass.newBufferDependency(lightVis.m_visiblesBufferHandle, BufferUsageBit::kSrvPixel);
 			pass.newTextureDependency(probeTexture, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(0, f, 0));
 
 			for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 			{
-				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(0, f, 0));
+				pass.newTextureDependency(gbufferColorRts[i], TextureUsageBit::kSrvPixel, TextureSubresourceDesc::surface(0, f, 0));
 			}
-			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSrvFragment, DepthStencilAspectBit::kDepth);
+			pass.newTextureDependency(gbufferDepthRt, TextureUsageBit::kSrvPixel, DepthStencilAspectBit::kDepth);
 
 			if(shadowMapRt.isValid())
 			{
-				pass.newTextureDependency(shadowMapRt, TextureUsageBit::kSrvFragment);
+				pass.newTextureDependency(shadowMapRt, TextureUsageBit::kSrvPixel);
 			}
 
 			if(getRenderer().getSky().isEnabled())
 			{
-				pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSrvFragment);
+				pass.newTextureDependency(getRenderer().getSky().getSkyLutRt(), TextureUsageBit::kSrvPixel);
 			}
 
 			pass.setWork([this, visResult = lightVis.m_visiblesBuffer, viewProjMat = frustum.getViewProjectionMatrix(),

AnKi/Renderer/RendererObject.cpp

@@ -53,7 +53,7 @@ Error RendererObject::loadShaderProgram(CString filename, std::initializer_list<
 		ANKI_ASSERT(techniqueIdx != kMaxU32);
 		const ShaderTypeBit techniqueShaderTypes = rsrc->getBinary().m_techniques[techniqueIdx].m_shaderTypes;
 
-		if(techniqueShaderTypes == (ShaderTypeBit::kCompute | ShaderTypeBit::kFragment | ShaderTypeBit::kVertex))
+		if(techniqueShaderTypes == (ShaderTypeBit::kCompute | ShaderTypeBit::kPixel | ShaderTypeBit::kVertex))
 		{
 			if(g_preferComputeCVar.get())
 			{
@@ -61,14 +61,14 @@ Error RendererObject::loadShaderProgram(CString filename, std::initializer_list<
 			}
 			else
 			{
-				shaderTypes = ShaderTypeBit::kFragment | ShaderTypeBit::kVertex;
+				shaderTypes = ShaderTypeBit::kPixel | ShaderTypeBit::kVertex;
 			}
 		}
 		else if(techniqueShaderTypes == ShaderTypeBit::kCompute)
 		{
 			shaderTypes = techniqueShaderTypes;
 		}
-		else if(techniqueShaderTypes == (ShaderTypeBit::kFragment | ShaderTypeBit::kVertex))
+		else if(techniqueShaderTypes == (ShaderTypeBit::kPixel | ShaderTypeBit::kVertex))
 		{
 			shaderTypes = techniqueShaderTypes;
 		}

AnKi/Renderer/RtShadows.cpp

@@ -99,7 +99,7 @@ Error RtShadows::initInternal()
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR8_Unorm,
 			TextureUsageBit::kAllSrv | TextureUsageBit::kUavTraceRays | TextureUsageBit::kUavCompute, "RtShadows History");
-		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
 	}
 
 	// Temp shadow RT
@@ -114,10 +114,10 @@ Error RtShadows::initInternal()
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
 			TextureUsageBit::kAllSrv | TextureUsageBit::kUavTraceRays | TextureUsageBit::kUavCompute, "RtShadows Moments #1");
-		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
 
 		texinit.setName("RtShadows Moments #2");
-		m_momentsRts[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+		m_momentsRts[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
 	}
 
 	// Variance RT
@@ -141,7 +141,7 @@ Error RtShadows::initInternal()
 			TextureUsageBit::kAllSrv | TextureUsageBit::kUavTraceRays | TextureUsageBit::kUavCompute, "RtShadows history len");
 		ClearValue clear;
 		clear.m_colorf[0] = 1.0f;
-		m_dummyHistoryLenTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment, clear);
+		m_dummyHistoryLenTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel, clear);
 	}
 
 	// Misc
@@ -166,9 +166,9 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 		if(!m_rtsImportedOnce) [[unlikely]]
 		{
-			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt.get(), TextureUsageBit::kSrvFragment);
+			m_runCtx.m_historyRt = rgraph.importRenderTarget(m_historyRt.get(), TextureUsageBit::kSrvPixel);
 
-			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx].get(), TextureUsageBit::kSrvFragment);
+			m_runCtx.m_prevMomentsRt = rgraph.importRenderTarget(m_momentsRts[prevRtIdx].get(), TextureUsageBit::kSrvPixel);
 
 			m_rtsImportedOnce = true;
 		}
@@ -285,7 +285,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSrvTraceRays);
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kUavTraceRays);
 		rpass.newAccelerationStructureDependency(getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle(),
-												 AccelerationStructureUsageBit::kTraceRaysRead);
+												 AccelerationStructureUsageBit::kTraceRaysSrv);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
 		rpass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSrvTraceRays);
 		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSrvTraceRays);

AnKi/Renderer/Scale.cpp

@@ -201,7 +201,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Scale");
 			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
-			pass.newTextureDependency(inRt, TextureUsageBit::kSrvFragment);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvPixel);
 			pass.newTextureDependency(outRt, TextureUsageBit::kRtvDsvWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -238,7 +238,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
-			pass.newTextureDependency(inRt, TextureUsageBit::kSrvFragment);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvPixel);
 			pass.newTextureDependency(outRt, TextureUsageBit::kRtvDsvWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
@@ -272,7 +272,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPass& pass = ctx.m_renderGraphDescr.newGraphicsRenderPass("Sharpen");
 			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(outRt)});
-			pass.newTextureDependency(inRt, TextureUsageBit::kSrvFragment);
+			pass.newTextureDependency(inRt, TextureUsageBit::kSrvPixel);
 			pass.newTextureDependency(outRt, TextureUsageBit::kRtvDsvWrite);
 
 			pass.setWork([this](RenderPassWorkContext& rgraphCtx) {

AnKi/Renderer/ShadowMapping.cpp

@@ -88,12 +88,12 @@ Error ShadowMapping::initInternal()
 					m_tileResolution * m_tileCountBothAxis);
 
 		// RT
-		const TextureUsageBit usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute | TextureUsageBit::kAllRtvDsv;
+		const TextureUsageBit usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kSrvCompute | TextureUsageBit::kAllRtvDsv;
 		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 			m_tileResolution * m_tileCountBothAxis, m_tileResolution * m_tileCountBothAxis, Format::kD16_Unorm, usage, "ShadowAtlas");
 		ClearValue clearVal;
 		clearVal.m_colorf[0] = 1.0f;
-		m_atlasTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment, clearVal);
+		m_atlasTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel, clearVal);
 	}
 
 	// Tiles
@@ -154,7 +154,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex.get(), TextureUsageBit::kSrvFragment);
+		m_runCtx.m_rt = rgraph.importRenderTarget(m_atlasTex.get(), TextureUsageBit::kSrvPixel);
 		m_rtImportedOnce = true;
 	}
 

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -90,16 +90,16 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kRtvDsvWrite);
 		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getRt() : getRenderer().getGBuffer().getDepthRt(),
-								   TextureUsageBit::kSrvFragment);
-		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSrvFragment);
+								   TextureUsageBit::kSrvPixel);
+		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSrvPixel);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvFragment);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kSrvPixel);
 		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
-								  BufferUsageBit::kSrvFragment);
+								  BufferUsageBit::kSrvPixel);
 
 		if(getRenderer().getRtShadowsEnabled())
 		{
-			rpass.newTextureDependency(getRenderer().getRtShadows().getRt(), TextureUsageBit::kSrvFragment);
+			rpass.newTextureDependency(getRenderer().getRtShadows().getRt(), TextureUsageBit::kSrvPixel);
 		}
 	}
 }

AnKi/Renderer/Sky.cpp

@@ -46,7 +46,7 @@ Error Sky::initInternal()
 		initialUsage);
 
 	m_skyLut = getRenderer().createAndClearRenderTarget(
-		getRenderer().create2DRenderTargetInitInfo(kSkyLutSize.x(), kSkyLutSize.y(), formatB, usage | TextureUsageBit::kSrvFragment, "SkyLut"),
+		getRenderer().create2DRenderTargetInitInfo(kSkyLutSize.x(), kSkyLutSize.y(), formatB, usage | TextureUsageBit::kSrvPixel, "SkyLut"),
 		initialUsage);
 
 	return Error::kNone;

AnKi/Renderer/Ssao.cpp

@@ -101,7 +101,7 @@ void Ssao::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		readUsage = TextureUsageBit::kSrvFragment;
+		readUsage = TextureUsageBit::kSrvPixel;
 		writeUsage = TextureUsageBit::kRtvDsvWrite;
 	}
 

AnKi/Renderer/Ssr.cpp

@@ -98,7 +98,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 
 		ppass = &pass;
 
-		readUsage = TextureUsageBit::kSrvFragment;
+		readUsage = TextureUsageBit::kSrvPixel;
 		writeUsage = TextureUsageBit::kRtvDsvWrite;
 	}
 

AnKi/Renderer/TemporalAA.cpp

@@ -33,14 +33,14 @@ Error TemporalAA::initInternal()
 
 	for(U32 i = 0; i < 2; ++i)
 	{
-		TextureUsageBit usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute;
+		TextureUsageBit usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kSrvCompute;
 		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kUavCompute : TextureUsageBit::kRtvDsvWrite;
 
 		TextureInitInfo texinit =
 			getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
 													   getRenderer().getHdrFormat(), usage, String().sprintf("TemporalAA #%u", i).cstr());
 
-		m_rtTextures[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+		m_rtTextures[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
 	}
 
 	m_tonemappedRtDescr = getRenderer().create2DRenderTargetDescription(
@@ -68,7 +68,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	}
 	else
 	{
-		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get(), TextureUsageBit::kSrvFragment);
+		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get(), TextureUsageBit::kSrvPixel);
 		m_rtTexturesImportedOnce = true;
 	}
 
@@ -97,7 +97,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(m_runCtx.m_renderRt, TextureUsageBit::kRtvDsvWrite);
 		pass.newTextureDependency(m_runCtx.m_tonemappedRt, TextureUsageBit::kRtvDsvWrite);
 
-		readUsage = TextureUsageBit::kSrvFragment;
+		readUsage = TextureUsageBit::kSrvPixel;
 
 		prpass = &pass;
 	}

AnKi/Renderer/Utils/HzbGenerator.cpp

@@ -263,7 +263,7 @@ void HzbGenerator::populateRenderGraphDirectionalLight(const HzbDirectionalLight
 		depthRt.m_loadOperation = RenderTargetLoadOperation::kClear;
 		pass.setRenderpassInfo({}, &depthRt);
 
-		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(maxDepthRt, TextureUsageBit::kSrvPixel);
 		pass.newTextureDependency(depthRts[i], TextureUsageBit::kRtvDsvWrite, DepthStencilAspectBit::kDepth);
 
 		pass.setWork([this, maxDepthRt, invViewProjMat = in.m_cameraInverseViewProjectionMatrix,

AnKi/Renderer/Utils/MipmapGenerator.cpp

@@ -28,7 +28,7 @@ void MipmapGenerator::populateRenderGraph(const MipmapGeneratorTargetArguments&
 				GraphicsRenderPass& rpass =
 					rgraph.newGraphicsRenderPass(generateTempPassName("%s: mip #%u face #%u layer #%u", passesName.cstr(), readMip, face, layer));
 
-				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kSrvFragment, TextureSubresourceDesc::surface(readMip, face, layer));
+				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kSrvPixel, TextureSubresourceDesc::surface(readMip, face, layer));
 				rpass.newTextureDependency(target.m_handle, TextureUsageBit::kRtvDsvWrite, TextureSubresourceDesc::surface(readMip + 1, face, layer));
 
 				GraphicsRenderPassTargetDesc rtInfo;

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -49,11 +49,11 @@ Error VolumetricLightingAccumulation::init()
 	// Create RTs
 	TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
 		m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
-		TextureUsageBit::kUavCompute | TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvCompute, "VolLight");
+		TextureUsageBit::kUavCompute | TextureUsageBit::kSrvPixel | TextureUsageBit::kSrvCompute, "VolLight");
 	texinit.m_depth = m_volumeSize[2];
 	texinit.m_type = TextureType::k3D;
-	m_rtTextures[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
-	m_rtTextures[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvFragment);
+	m_rtTextures[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
+	m_rtTextures[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSrvPixel);
 
 	return Error::kNone;
 }
@@ -65,7 +65,7 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 	const U readRtIdx = getRenderer().getFrameCount() & 1;
 
-	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx].get(), TextureUsageBit::kSrvFragment);
+	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx].get(), TextureUsageBit::kSrvPixel);
 	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx].get(), TextureUsageBit::kNone);
 
 	NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Vol light");

AnKi/Resource/ImageResource.cpp

@@ -312,7 +312,7 @@ Error ImageResource::load(LoadingContext& ctx)
 			unflatten3dArrayIndex(ctx.m_layerCount, ctx.m_faces, ctx.m_loader.getMipmapCount(), i, layer, face, mip);
 
 			barriers[barrierCount++] = {TextureView(ctx.m_tex.get(), TextureSubresourceDesc::surface(mip, face, layer)),
-										TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment | TextureUsageBit::kSrvGeometry};
+										TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel | TextureUsageBit::kSrvGeometry};
 		}
 		cmdb->setPipelineBarrier({&barriers[0], barrierCount}, {}, {});
 

AnKi/Resource/MaterialResource.cpp

@@ -574,33 +574,33 @@ const MaterialVariant& MaterialResource::getOrCreateVariant(const RenderingKey&
 	case RenderingTechnique::kGBuffer:
 		if(key.getMeshletRendering() && meshShadersSupported)
 		{
-			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kMesh | ShaderTypeBit::kFragment, "GBufferMeshShaders");
+			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kMesh | ShaderTypeBit::kPixel, "GBufferMeshShaders");
 		}
 		else if(key.getMeshletRendering())
 		{
-			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kFragment, "GBufferSwMeshletRendering");
+			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "GBufferSwMeshletRendering");
 		}
 		else
 		{
-			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kFragment, "GBufferLegacy");
+			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "GBufferLegacy");
 		}
 		break;
 	case RenderingTechnique::kDepth:
 		if(key.getMeshletRendering() && meshShadersSupported)
 		{
-			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kMesh | ShaderTypeBit::kFragment, "ShadowsMeshShaders");
+			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kMesh | ShaderTypeBit::kPixel, "ShadowsMeshShaders");
 		}
 		else if(key.getMeshletRendering())
 		{
-			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kFragment, "ShadowsSwMeshletRendering");
+			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "ShadowsSwMeshletRendering");
 		}
 		else
 		{
-			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kFragment, "ShadowsLegacy");
+			initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "ShadowsLegacy");
 		}
 		break;
 	case RenderingTechnique::kForward:
-		initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kFragment, "Forward");
+		initInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "Forward");
 		break;
 	case RenderingTechnique::kRtShadow:
 		initInfo.requestTechniqueAndTypes(ShaderTypeBit::kAllHit, "RtShadows");

AnKi/Resource/ShaderProgramResource.cpp

@@ -69,7 +69,7 @@ void ShaderProgramResource::getOrCreateVariant(const ShaderProgramResourceVarian
 		ANKI_ASSERT(techniqueIdx != kMaxU32);
 		const ShaderTypeBit techniqueShaderTypes = m_binary->m_techniques[techniqueIdx].m_shaderTypes;
 
-		if(techniqueShaderTypes == (ShaderTypeBit::kFragment | ShaderTypeBit::kVertex))
+		if(techniqueShaderTypes == (ShaderTypeBit::kPixel | ShaderTypeBit::kVertex))
 		{
 			info.requestTechniqueAndTypes(techniqueShaderTypes, "Unnamed");
 		}

AnKi/Scene/RenderStateBucket.cpp

@@ -159,7 +159,7 @@ void RenderStateBucketContainer::createPerfOrder(RenderingTechnique t)
 
 	std::sort(m_bucketPerfOrder[t].getBegin(), m_bucketPerfOrder[t].getBegin() + bucketCount, [&, this](U32 a, U32 b) {
 		auto getProgramHeaviness = [](const ShaderProgram& p) {
-			U64 size = U64(p.getShaderBinarySize(ShaderType::kFragment)) << 32u; // Fragment is more important
+			U64 size = U64(p.getShaderBinarySize(ShaderType::kPixel)) << 32u; // Fragment is more important
 			if(!!(p.getShaderTypes() & ShaderTypeBit::kVertex))
 			{
 				size |= p.getShaderBinarySize(ShaderType::kVertex);

AnKi/ShaderCompiler/Dxc.cpp

@@ -21,19 +21,19 @@ static CString profile(ShaderType shaderType)
 	case ShaderType::kVertex:
 		return "vs_6_8";
 		break;
-	case ShaderType::kFragment:
+	case ShaderType::kPixel:
 		return "ps_6_8";
 		break;
-	case ShaderType::kTessellationEvaluation:
+	case ShaderType::kDomain:
 		return "ds_6_8";
 		break;
-	case ShaderType::kTessellationControl:
+	case ShaderType::kHull:
 		return "ds_6_8";
 		break;
 	case ShaderType::kGeometry:
 		return "gs_6_8";
 		break;
-	case ShaderType::kTask:
+	case ShaderType::kAmplification:
 		return "as_6_8";
 		break;
 	case ShaderType::kMesh:

AnKi/ShaderCompiler/MaliOfflineCompiler.cpp

@@ -116,7 +116,7 @@ Error runMaliOfflineCompiler(ConstWeakArray<U8> spirv, ShaderType shaderType, Ma
 	case ShaderType::kVertex:
 		args[0] = "-v";
 		break;
-	case ShaderType::kFragment:
+	case ShaderType::kPixel:
 		args[0] = "-f";
 		break;
 	case ShaderType::kCompute:
@@ -224,7 +224,7 @@ Error runMaliOfflineCompiler(ConstWeakArray<U8> spirv, ShaderType shaderType, Ma
 			return Error::kFunctionFailed;
 		}
 	}
-	else if(shaderType == ShaderType::kFragment)
+	else if(shaderType == ShaderType::kPixel)
 	{
 		if(std::regex_search(analysisTextStl, match,
 							 std::regex("Total instruction cycles:\\s*" ANKI_FLOAT_REGEX "\\s*" ANKI_FLOAT_REGEX "\\s*" ANKI_FLOAT_REGEX

AnKi/ShaderCompiler/RadeonGpuAnalyzer.cpp

@@ -21,7 +21,7 @@ static CString getPipelineStageString(ShaderType shaderType)
 	case ShaderType::kVertex:
 		out = "vert";
 		break;
-	case ShaderType::kFragment:
+	case ShaderType::kPixel:
 		out = "frag";
 		break;
 	case ShaderType::kCompute:

AnKi/ShaderCompiler/ShaderCompiler.cpp

@@ -255,14 +255,14 @@ Error doReflectionSpirv(ConstWeakArray<U8> spirv, ShaderType type, ShaderReflect
 	}
 
 	// Color attachments
-	if(type == ShaderType::kFragment)
+	if(type == ShaderType::kPixel)
 	{
 		for(const spirv_cross::Resource& r : rsrc.stage_outputs)
 		{
 			const U32 id = r.id;
 			const U32 location = spvc.get_decoration(id, spv::Decoration::DecorationLocation);
 
-			refl.m_fragment.m_colorAttachmentWritemask.set(location);
+			refl.m_pixel.m_colorRenderTargetWritemask.set(location);
 		}
 	}
 
@@ -340,13 +340,13 @@ Error doReflectionSpirv(ConstWeakArray<U8> spirv, ShaderType type, ShaderReflect
 	}
 
 	// Discards?
-	if(type == ShaderType::kFragment)
+	if(type == ShaderType::kPixel)
 	{
 		visitSpirv(ConstWeakArray<U32>(reinterpret_cast<const U32*>(&spirv[0]), spirv.getSize() / sizeof(U32)),
 				   [&](U32 cmd, [[maybe_unused]] ConstWeakArray<U32> instructions) {
 					   if(cmd == spv::OpKill)
 					   {
-						   refl.m_fragment.m_discards = true;
+						   refl.m_pixel.m_discards = true;
 					   }
 				   });
 	}
@@ -629,7 +629,7 @@ Error doReflectionDxil(ConstWeakArray<U8> dxil, ShaderType type, ShaderReflectio
 		}
 	}
 
-	if(type == ShaderType::kFragment)
+	if(type == ShaderType::kPixel)
 	{
 		for(U32 i = 0; i < shaderDesc.OutputParameters; ++i)
 		{
@@ -638,7 +638,7 @@ Error doReflectionDxil(ConstWeakArray<U8> dxil, ShaderType type, ShaderReflectio
 
 			if(CString(desc.SemanticName) == "SV_TARGET")
 			{
-				refl.m_fragment.m_colorAttachmentWritemask.set(desc.SemanticIndex);
+				refl.m_pixel.m_colorRenderTargetWritemask.set(desc.SemanticIndex);
 			}
 		}
 	}

AnKi/ShaderCompiler/ShaderParser.cpp

@@ -15,9 +15,9 @@ namespace anki {
 	ANKI_SHADER_COMPILER_LOGE("%s: " msg_ ": %s", fname.cstr(), line.cstr()); \
 	return Error::kUserData
 
-inline constexpr Array<CString, U32(ShaderType::kCount)> kShaderStageNames = {
-	{"VERTEX", "TESSELLATION_CONTROL", "TESSELLATION_EVALUATION", "GEOMETRY", "TASK", "MESH", "FRAGMENT", "COMPUTE", "RAY_GEN", "ANY_HIT",
-	 "CLOSEST_HIT", "MISS", "INTERSECTION", "CALLABLE", "WORK_GRAPH"}};
+inline constexpr Array<CString, U32(ShaderType::kCount)> kShaderStageNames = {{"VERTEX", "HULL", "DOMAIN", "GEOMETRY", "AMPLIFICATION", "MESH",
+																			   "PIXEL", "COMPUTE", "RAY_GEN", "ANY_HIT", "CLOSEST_HIT", "MISS",
+																			   "INTERSECTION", "CALLABLE", "WORK_GRAPH"}};
 
 static ShaderType strToShaderType(CString str)
 {
@@ -26,28 +26,28 @@ static ShaderType strToShaderType(CString str)
 	{
 		shaderType = ShaderType::kVertex;
 	}
-	else if(str == "tessc")
+	else if(str == "hull")
 	{
-		shaderType = ShaderType::kTessellationControl;
+		shaderType = ShaderType::kHull;
 	}
-	else if(str == "tesse")
+	else if(str == "domain")
 	{
 	}
 	else if(str == "geom")
 	{
 		shaderType = ShaderType::kGeometry;
 	}
-	else if(str == "task")
+	else if(str == "ampl")
 	{
-		shaderType = ShaderType::kTask;
+		shaderType = ShaderType::kAmplification;
 	}
 	else if(str == "mesh")
 	{
 		shaderType = ShaderType::kMesh;
 	}
-	else if(str == "frag")
+	else if(str == "pixel")
 	{
-		shaderType = ShaderType::kFragment;
+		shaderType = ShaderType::kPixel;
 	}
 	else if(str == "comp")
 	{

AnKi/Shaders/Blit.ankiprog

@@ -5,7 +5,7 @@
 
 #include <AnKi/Shaders/QuadVert.hlsl>
 
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/Functions.hlsl>
 
 SamplerState g_linearAnyClampSampler : register(s0);
@@ -53,13 +53,13 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return color;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/Bloom.ankiprog

@@ -4,7 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include <AnKi/Shaders/QuadVert.hlsl>
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
 #	include <AnKi/Shaders/Functions.hlsl>
 
@@ -59,13 +59,13 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return color;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/BloomUpscale.ankiprog

@@ -4,7 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include <AnKi/Shaders/QuadVert.hlsl>
-#if ANKI_FRAGMENT_SHADER || ANKI_COMPUTE_SHADER
+#if ANKI_PIXEL_SHADER || ANKI_COMPUTE_SHADER
 #	include <AnKi/Shaders/Functions.hlsl>
 
 // Constants
@@ -113,13 +113,13 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return outColor;
 #	endif
 }
-#endif // ANKI_FRAGMENT_SHADER || ANKI_COMPUTE_SHADER
+#endif // ANKI_PIXEL_SHADER || ANKI_COMPUTE_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/DbgBillboard.ankiprog

@@ -99,7 +99,7 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/ImportanceSampling.hlsl>
 
 SamplerState g_trilinearRepeatSampler : register(s1);
@@ -140,4 +140,4 @@ Vec4 main(VertOut input) : SV_TARGET0
 		return g_tex2.Sample(g_trilinearRepeatSampler, input.m_uv) * input.m_colorScale * colorFactor;
 	}
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/DbgRenderables.ankiprog

@@ -54,7 +54,7 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/ImportanceSampling.hlsl>
 
 // NOTE: Don't eliminate the binding because it confuses the descriptor set creation
@@ -83,4 +83,4 @@ Vec4 main(VertOut input) : SV_TARGET0
 	// Write the color
 	return g_consts.m_color;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/DepthAwareBlur.ankiprog

@@ -11,7 +11,7 @@
 #include <AnKi/Shaders/Common.hlsl>
 #include <AnKi/Shaders/BilateralFilter.hlsl>
 
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	define ORIENTATION_VERTICAL 0
 #	define ORIENTATION_HORIZONTAL 1
 #	define ORIENTATION_BOX 2
@@ -128,13 +128,13 @@ ColorType main(VertOut input) : SV_TARGET0
 	return color;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/DepthDownscale.ankiprog

@@ -98,7 +98,7 @@ AF4 SpdReduce4(AF4 v0, AF4 v1, AF4 v2, AF4 v3)
 #include <AnKi/Shaders/QuadVert.hlsl>
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/QuadVert.hlsl>
 
 Texture2D<Vec4> g_inputTex : register(t0);
@@ -108,4 +108,4 @@ F32 main(VertOut input) : SV_TARGET0
 {
 	return g_inputTex.SampleLevel(g_linearAnyClampSampler, input.m_uv, 0.0).x;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/DownscaleBlur.ankiprog

@@ -4,7 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include <AnKi/Shaders/QuadVert.hlsl>
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
 #	include <AnKi/Shaders/Functions.hlsl>
 
@@ -51,13 +51,13 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return output;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/FinalComposite.ankiprog

@@ -12,7 +12,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/Functions.hlsl>
 #include <AnKi/Shaders/MotionBlur.hlsl>
 
@@ -85,4 +85,4 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return outColor;
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/ForwardShadingCommon.hlsl

@@ -16,13 +16,13 @@
 //
 // Frag
 //
-#if ANKI_FRAGMENT_SHADER
-struct FragOut
+#if ANKI_PIXEL_SHADER
+struct PixelOut
 {
 	RVec4 m_color : SV_TARGET0;
 };
 
-void packGBuffer(Vec4 color, out FragOut output)
+void packGBuffer(Vec4 color, out PixelOut output)
 {
 	output.m_color = RVec4(color.rgb, color.a);
 }
@@ -107,12 +107,12 @@ RVec3 computeLightColorLow(RVec3 diffCol, RVec3 worldPos, Vec4 svPosition)
 	return diffuseLobe(diffCol) * light;
 }
 
-void particleAlpha(RVec4 color, RVec4 scaleColor, RVec4 biasColor, out FragOut output)
+void particleAlpha(RVec4 color, RVec4 scaleColor, RVec4 biasColor, out PixelOut output)
 {
 	packGBuffer(color * scaleColor + biasColor, output);
 }
 
-void fog(RVec3 color, RF32 fogAlphaScale, RF32 fogDistanceOfMaxThikness, F32 zVSpace, Vec2 svPosition, out FragOut output)
+void fog(RVec3 color, RF32 fogAlphaScale, RF32 fogDistanceOfMaxThikness, F32 zVSpace, Vec2 svPosition, out PixelOut output)
 {
 	const Vec2 screenSize = 1.0 / g_globalRendererConstants.m_renderingSize;
 
@@ -130,4 +130,4 @@ void fog(RVec3 color, RF32 fogAlphaScale, RF32 fogDistanceOfMaxThikness, F32 zVS
 	packGBuffer(Vec4(color, zFeatherFactor * fogAlphaScale), output);
 }
 
-#endif // ANKI_FRAGMENT_SHADER
+#endif // ANKI_PIXEL_SHADER

AnKi/Shaders/ForwardShadingFog.ankiprog

@@ -49,11 +49,11 @@ VertOut main(VertIn input)
 
 #pragma anki technique_end vert Forward
 
-#pragma anki technique_start frag Forward
+#pragma anki technique_start pixel Forward
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 {
-	FragOut output = (FragOut)0;
+	PixelOut output = (PixelOut)0;
 	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
 
 	fog(localConstants.m_fogColor, localConstants.m_fogAlphaScale, localConstants.m_fogDistanceOfMaxThikness, input.m_svPosition, input.m_zVSpace,
@@ -61,4 +61,4 @@ FragOut main(VertOut input)
 
 	return output;
 }
-#pragma anki technique_end frag Forward
+#pragma anki technique_end pixel Forward

AnKi/Shaders/ForwardShadingGenericTransparent.ankiprog

@@ -50,12 +50,12 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert Forward
 
-#pragma anki technique_start frag Forward
+#pragma anki technique_start pixel Forward
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 {
 	ANKI_MAYBE_UNUSED(input);
-	FragOut output;
+	PixelOut output;
 
 	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, WaveReadLaneFirst(input.m_constantsOffset));
 
@@ -73,4 +73,4 @@ FragOut main(VertOut input)
 
 	return output;
 }
-#pragma anki technique_end frag Forward
+#pragma anki technique_end pixel Forward

AnKi/Shaders/ForwardShadingParticles.ankiprog

@@ -68,11 +68,11 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert Forward
 
-#pragma anki technique_start frag Forward
+#pragma anki technique_start pixel Forward
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 {
-	FragOut output = (FragOut)0;
+	PixelOut output = (PixelOut)0;
 	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, WaveReadLaneFirst(input.m_constantsOffset));
 
 #if ANIMATED_TEXTURE == 1
@@ -92,4 +92,4 @@ FragOut main(VertOut input)
 
 	return output;
 }
-#pragma anki technique_end frag Forward
+#pragma anki technique_end pixel Forward

AnKi/Shaders/Fsr.ankiprog

@@ -9,7 +9,7 @@
 
 #include <AnKi/Shaders/QuadVert.hlsl>
 
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/Functions.hlsl>
 
 SamplerState g_linearAnyClampSampler : register(s0);
@@ -110,13 +110,13 @@ Vec3 main(VertOut input) : SV_TARGET0
 	return HVec3(color);
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/Functions.hlsl

@@ -56,7 +56,7 @@ Vec3 cheapPerspectiveUnprojection(Vec4 unprojParams, Vec2 ndc, F32 depth)
 	return Vec3(xy, z);
 }
 
-#if ANKI_FRAGMENT_SHADER
+#if ANKI_PIXEL_SHADER
 // Stolen from shadertoy.com/view/4tyGDD
 Vec4 textureCatmullRom4Samples(Texture2D tex, SamplerState sampl, Vec2 uv, Vec2 texSize)
 {
@@ -567,7 +567,7 @@ vector<T, 3> animateBlueNoise(vector<T, 3> inputBlueNoise, U32 frameIdx)
 	return frac(inputBlueNoise + T(frameIdx % 64u) * goldenRatioConjugate);
 }
 
-#if ANKI_FRAGMENT_SHADER
+#if ANKI_PIXEL_SHADER
 /// https://bgolus.medium.com/distinctive-derivative-differences-cce38d36797b
 /// normalizedUvs is uv*textureResolution
 F32 computeMipLevel(Vec2 normalizedUvs)

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -37,7 +37,7 @@
 #	define PARALLAX 0
 #endif
 
-#if ANKI_TASK_SHADER
+#if ANKI_AMPLIFICATION_SHADER
 #	define ALPHA_TEST 0
 #	define DIFFUSE_TEX 0
 #	define ANKI_VELOCITY 0
@@ -153,7 +153,7 @@ struct MeshPerPrimitiveOut
 	ANKI_PER_PRIMITIVE_MEMBER Bool m_cullPrimitive : SV_CULLPRIMITIVE;
 };
 
-struct FragOut
+struct PixelOut
 {
 	Vec4 m_color0 : SV_TARGET0;
 	Vec4 m_color1 : SV_TARGET1;
@@ -443,7 +443,7 @@ main(U32 svGroupId : SV_GROUPID, U32 svGroupIndex : SV_GROUPINDEX, out vertices
 // ===========================================================================
 // Frag                                                                      =
 // ===========================================================================
-#if ANKI_FRAGMENT_SHADER
+#if ANKI_PIXEL_SHADER
 
 #	if SW_MESHLETS
 #		define BINDLESS(x) getBindlessTextureNonUniformIndex2DRVec4(x)
@@ -483,7 +483,7 @@ void main(
 
 #	else // GBUFFER
 
-FragOut main(
+PixelOut main(
 #		if ANKI_TECHNIQUE_GBufferMeshShaders
 	MeshPerVertOut vertInput, ANKI_PER_PRIMITIVE_VAR MeshPerPrimitiveOut primInput
 #		else
@@ -598,12 +598,12 @@ FragOut main(
 	}
 #		endif
 
-	FragOut output;
+	PixelOut output;
 	packGBuffer(g, output.m_color0, output.m_color1, output.m_color2, output.m_color3);
 	return output;
 }
 #	endif
-#endif // ANKI_FRAGMENT_SHADER
+#endif // ANKI_PIXEL_SHADER
 
 // ===========================================================================
 // RT Shadows                                                                =
@@ -685,23 +685,23 @@ FragOut main(
 #pragma anki technique_start mesh ShadowsMeshShaders uses_mutators ANKI_VELOCITY ANKI_BONES DIFFUSE_TEX PARALLAX ALPHA_TEST
 #pragma anki technique_end mesh ShadowsMeshShaders
 
-#pragma anki technique_start frag GBufferLegacy
-#pragma anki technique_end frag GBufferLegacy
+#pragma anki technique_start pixel GBufferLegacy
+#pragma anki technique_end pixel GBufferLegacy
 
-#pragma anki technique_start frag ShadowsLegacy
-#pragma anki technique_end frag ShadowsLegacy
+#pragma anki technique_start pixel ShadowsLegacy
+#pragma anki technique_end pixel ShadowsLegacy
 
-#pragma anki technique_start frag GBufferMeshShaders
-#pragma anki technique_end frag GBufferMeshShaders
+#pragma anki technique_start pixel GBufferMeshShaders
+#pragma anki technique_end pixel GBufferMeshShaders
 
-#pragma anki technique_start frag ShadowsMeshShaders
-#pragma anki technique_end frag ShadowsMeshShaders
+#pragma anki technique_start pixel ShadowsMeshShaders
+#pragma anki technique_end pixel ShadowsMeshShaders
 
-#pragma anki technique_start frag GBufferSwMeshletRendering
-#pragma anki technique_end frag GBufferSwMeshletRendering
+#pragma anki technique_start pixel GBufferSwMeshletRendering
+#pragma anki technique_end pixel GBufferSwMeshletRendering
 
-#pragma anki technique_start frag ShadowsSwMeshletRendering
-#pragma anki technique_end frag ShadowsSwMeshletRendering
+#pragma anki technique_start pixel ShadowsSwMeshletRendering
+#pragma anki technique_end pixel ShadowsSwMeshletRendering
 
 #pragma anki technique_start ahit RtShadows uses_mutators ALPHA_TEST DIFFUSE_TEX
 #pragma anki technique_end ahit RtShadows

AnKi/Shaders/GBufferGpuParticles.ankiprog

@@ -28,7 +28,7 @@ struct VertOut
 	Vec4 m_svPosition : SV_POSITION;
 };
 
-struct FragOut
+struct PixelOut
 {
 	Vec4 m_color0 : SV_TARGET0;
 	Vec4 m_color1 : SV_TARGET1;
@@ -78,12 +78,12 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert GBuffer
 
-#pragma anki technique_start frag GBuffer
+#pragma anki technique_start pixel GBuffer
 #include <AnKi/Shaders/PackFunctions.hlsl>
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 {
-	FragOut output;
+	PixelOut output;
 	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, input.m_constantsOffset);
 
 	GbufferInfo g;
@@ -101,4 +101,4 @@ FragOut main(VertOut input)
 	packGBuffer(g, output.m_color0, output.m_color1, output.m_color2, output.m_color3);
 	return output;
 }
-#pragma anki technique_end frag GBuffer
+#pragma anki technique_end pixel GBuffer

AnKi/Shaders/GBufferPost.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/PackFunctions.hlsl>
 #include <AnKi/Shaders/Functions.hlsl>
 #include <AnKi/Shaders/ClusteredShadingFunctions.hlsl>
@@ -22,13 +22,13 @@ ConstantBuffer<GlobalRendererConstants> g_globalConstants : register(b0);
 StructuredBuffer<Decal> g_decals : register(t1);
 StructuredBuffer<Cluster> g_clusters : register(t2);
 
-struct FragOut
+struct PixelOut
 {
 	RVec4 m_diffuse : SV_TARGET0;
 	RVec4 m_roughnessAndOther : SV_TARGET1;
 };
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 {
 	const Vec2 uv = input.m_uv;
 
@@ -113,9 +113,9 @@ FragOut main(VertOut input)
 		roughnessAndOther.a *= (1.0 - f);
 	}
 
-	FragOut output;
+	PixelOut output;
 	output.m_diffuse = diffuse;
 	output.m_roughnessAndOther = roughnessAndOther;
 	return output;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/GBufferVisualizeGiProbe.ankiprog

@@ -37,7 +37,7 @@ struct VertOut
 	Vec3 m_sphereCenter : SpherePosition;
 };
 
-struct FragOut
+struct PixelOut
 {
 	Vec4 m_color0 : SV_TARGET0;
 	Vec4 m_color1 : SV_TARGET1;
@@ -111,11 +111,11 @@ VertOut main(VertIn input)
 
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 {
-	FragOut output = (FragOut)0;
+	PixelOut output = (PixelOut)0;
 
 	// Compute the far point
 	const Vec2 ndc = uvToNdc(input.m_svPosition.xy / g_consts.m_viewportSize);
@@ -154,4 +154,4 @@ FragOut main(VertOut input)
 	return output;
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/GenTextureFuncs.py

@@ -342,7 +342,7 @@ def gen_split_sampler_tex_func(func):
     for func in func_instances:
         # Shader guard
         if not func.all_shader_stages:
-            out += "#if ANKI_FRAGMENT_SHADER\n"
+            out += "#if ANKI_PIXEL_SHADER\n"
 
         # Return type
         out += write_type(func.return_type) + " "

AnKi/Shaders/HzbMaxDepthProject.ankiprog

@@ -68,10 +68,10 @@ Vec4 main(U32 svVertexId : SV_VERTEXID, U32 svInstanceId : SV_INSTANCEID) : SV_P
 
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
 void main()
 {
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/Intellisense.hlsl

@@ -30,9 +30,9 @@
 #define ANKI_END_NAMESPACE
 #define ANKI_HLSL 1
 
-#define ANKI_TASK_SHADER 1
+#define ANKI_AMPLIFICATION_SHADER 1
 #define ANKI_VERTEX_SHADER 1
-#define ANKI_FRAGMENT_SHADER 1
+#define ANKI_PIXEL_SHADER 1
 #define ANKI_MESH_SHADER 1
 #define ANKI_COMPUTE_SHADER 1
 #define ANKI_CLOSEST_HIT_SHADER 1

AnKi/Shaders/LensFlareSprite.ankiprog

@@ -37,7 +37,7 @@ VertOut main(U32 svVertexId : SV_VERTEXID, U32 svInstanceId : SV_INSTANCEID)
 }
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
 SamplerState g_trilinearRepeatSampler : register(s0);
 Texture2DArray<RVec4> g_tex : register(t1);
@@ -47,4 +47,4 @@ RVec4 main(VertOut input) : SV_TARGET0
 	const RVec4 col = g_tex.Sample(g_trilinearRepeatSampler, input.m_uv);
 	return col * input.m_color;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/LightShading.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/PackFunctions.hlsl>
 #include <AnKi/Shaders/Functions.hlsl>
 #include <AnKi/Shaders/RtShadows.hlsl>
@@ -253,4 +253,4 @@ RVec3 main(VertOut input) : SV_TARGET0
 	outColor = min(outColor, RVec3(kMaxRF32, kMaxRF32, kMaxRF32));
 	return outColor;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/LightShadingApplyFog.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/Functions.hlsl>
 
 SamplerState g_nearestAnyClampSampler : register(s0);
@@ -47,4 +47,4 @@ RVec4 main(VertOut input) : SV_TARGET0
 	return RVec4(inScattering, transmittance);
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/LightShadingSkybox.ankiprog

@@ -11,7 +11,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
 #include <AnKi/Shaders/Include/MiscRendererTypes.h>
 #include <AnKi/Shaders/Functions.hlsl>
@@ -89,4 +89,4 @@ RVec3 main(VertOut input) : SV_TARGET0
 #endif
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/MipmapGenerator.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 Texture2D<Vec4> g_inputTex : register(t0);
 SamplerState g_linearAnyClampSampler : register(s0);
 
@@ -16,4 +16,4 @@ Vec4 main(VertOut input) : SV_TARGET0
 {
 	return g_inputTex.SampleLevel(g_linearAnyClampSampler, input.m_uv, 0.0f);
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/MotionVectors.ankiprog

@@ -7,7 +7,7 @@
 
 #include <AnKi/Shaders/QuadVert.hlsl>
 
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/Functions.hlsl>
 
 constexpr F32 kMaxRejectionDistance = 0.1; // In meters
@@ -32,12 +32,12 @@ RWTexture2D<Vec2> g_motionVectorsStorageTex : register(u0);
 #	if ANKI_COMPUTE_SHADER
 [numthreads(8, 8, 1)] void main(UVec2 svDispatchThreadId : SV_DISPATCHTHREADID)
 #	else
-struct FragOut
+struct PixelOut
 {
 	Vec2 m_motionVectors : SV_TARGET0;
 };
 
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
@@ -77,18 +77,18 @@ FragOut main(VertOut input)
 #	if ANKI_COMPUTE_SHADER
 	g_motionVectorsStorageTex[svDispatchThreadId] = historyUv - uv;
 #	else
-	FragOut output;
+	PixelOut output;
 	output.m_motionVectors = historyUv - uv;
 	return output;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/ShadowMappingClearDepth.ankiprog

@@ -17,8 +17,8 @@ Vec4 main(U32 svVertexId : SV_VERTEXID) : SV_POSITION
 
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 void main()
 {
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/ShadowmapsResolve.ankiprog

@@ -7,7 +7,7 @@
 #pragma anki mutator DIRECTIONAL_LIGHT_SHADOW_RESOLVED 0 1
 
 #include <AnKi/Shaders/QuadVert.hlsl>
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/ClusteredShadingFunctions.hlsl>
 
 #	define DEBUG_CASCADES 0
@@ -217,13 +217,13 @@ RVec4 main(VertOut input) : SV_TARGET0
 	return shadowFactors;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/Ssao.ankiprog

@@ -12,7 +12,7 @@
 // ===========================================================================
 // SSAO                                                                      =
 // ===========================================================================
-#if ANKI_TECHNIQUE_Ssao && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
+#if ANKI_TECHNIQUE_Ssao && (ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER)
 #	include <AnKi/Shaders/Include/MiscRendererTypes.h>
 #	include <AnKi/Shaders/Functions.hlsl>
 #	include <AnKi/Shaders/PackFunctions.hlsl>
@@ -163,12 +163,12 @@ RVec4 main(VertOut input) : SV_TARGET0
 	return RVec4(bentNormal, Vd);
 #	endif
 }
-#endif // ANKI_TECHNIQUE_Ssao && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
+#endif // ANKI_TECHNIQUE_Ssao && (ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER)
 
 // ===========================================================================
 // SSAO spatial denoise                                                      =
 // ===========================================================================
-#if ANKI_TECHNIQUE_SsaoSpatialDenoise && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
+#if ANKI_TECHNIQUE_SsaoSpatialDenoise && (ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER)
 #	include <AnKi/Shaders/BilateralFilter.hlsl>
 #	include <AnKi/Shaders/Include/MiscRendererTypes.h>
 #	include <AnKi/Shaders/Functions.hlsl>
@@ -264,7 +264,7 @@ RVec4 main(VertOut input) : SV_TARGET0
 // ===========================================================================
 // SSAO temporal denoise                                                     =
 // ===========================================================================
-#if ANKI_TECHNIQUE_SsaoTemporalDenoise && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
+#if ANKI_TECHNIQUE_SsaoTemporalDenoise && (ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER)
 #	include <AnKi/Shaders/Functions.hlsl>
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
 
@@ -351,8 +351,8 @@ RVec4 main(VertOut input) : SV_TARGET0
 #pragma anki technique_start vert Ssao uses_mutators
 #pragma anki technique_end vert Ssao
 
-#pragma anki technique_start frag Ssao uses_mutators
-#pragma anki technique_end frag Ssao
+#pragma anki technique_start pixel Ssao uses_mutators
+#pragma anki technique_end pixel Ssao
 
 #pragma anki technique_start comp Ssao
 #pragma anki technique_end comp Ssao
@@ -360,8 +360,8 @@ RVec4 main(VertOut input) : SV_TARGET0
 #pragma anki technique_start vert SsaoSpatialDenoise
 #pragma anki technique_end vert SsaoSpatialDenoise
 
-#pragma anki technique_start frag SsaoSpatialDenoise
-#pragma anki technique_end frag SsaoSpatialDenoise
+#pragma anki technique_start pixel SsaoSpatialDenoise
+#pragma anki technique_end pixel SsaoSpatialDenoise
 
 #pragma anki technique_start comp SsaoSpatialDenoise
 #pragma anki technique_end comp SsaoSpatialDenoise
@@ -369,8 +369,8 @@ RVec4 main(VertOut input) : SV_TARGET0
 #pragma anki technique_start vert SsaoTemporalDenoise
 #pragma anki technique_end vert SsaoTemporalDenoise
 
-#pragma anki technique_start frag SsaoTemporalDenoise
-#pragma anki technique_end frag SsaoTemporalDenoise
+#pragma anki technique_start pixel SsaoTemporalDenoise
+#pragma anki technique_end pixel SsaoTemporalDenoise
 
 #pragma anki technique_start comp SsaoTemporalDenoise
 #pragma anki technique_end comp SsaoTemporalDenoise

AnKi/Shaders/Ssr.ankiprog

@@ -10,7 +10,7 @@
 // ===========================================================================
 // SSR                                                                       =
 // ===========================================================================
-#if ANKI_TECHNIQUE_Ssr && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
+#if ANKI_TECHNIQUE_Ssr && (ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER)
 #	include <AnKi/Shaders/Include/MiscRendererTypes.h>
 #	include <AnKi/Shaders/Functions.hlsl>
 #	include <AnKi/Shaders/PackFunctions.hlsl>
@@ -151,7 +151,7 @@ RVec4 main(VertOut input) : SV_TARGET0
 #	endif
 }
 
-#endif // ANKI_TECHNIQUE_Ssr && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
+#endif // ANKI_TECHNIQUE_Ssr && (ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER)
 
 // ===========================================================================
 // Techniques                                                                =
@@ -159,8 +159,8 @@ RVec4 main(VertOut input) : SV_TARGET0
 #pragma anki technique_start vert Ssr
 #pragma anki technique_end vert Ssr
 
-#pragma anki technique_start frag Ssr
-#pragma anki technique_end frag Ssr
+#pragma anki technique_start pixel Ssr
+#pragma anki technique_end pixel Ssr
 
 #pragma anki technique_start comp Ssr
 #pragma anki technique_end comp Ssr

AnKi/Shaders/TemporalAA.ankiprog

@@ -7,7 +7,7 @@
 #pragma anki mutator YCBCR 0 1
 
 #include <AnKi/Shaders/QuadVert.hlsl>
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/Functions.hlsl>
 #	include <AnKi/Shaders/PackFunctions.hlsl>
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
@@ -27,7 +27,7 @@ Texture2D g_motionVectorsTex : register(t2);
 RWTexture2D<RVec4> g_storageTex : register(u1);
 RWTexture2D<RVec4> g_tonemappedStorageTex : register(u2);
 #	else
-struct FragOut
+struct PixelOut
 {
 	RVec3 m_color : SV_TARGET0;
 	RVec3 m_tonemappedColor : SV_TARGET1;
@@ -45,7 +45,7 @@ struct FragOut
 #	if ANKI_COMPUTE_SHADER
 [numthreads(8, 8, 1)] void main(UVec3 svDispatchThreadId : SV_DISPATCHTHREADID)
 #	else
-FragOut main(VertOut input)
+PixelOut main(VertOut input)
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
@@ -112,19 +112,19 @@ FragOut main(VertOut input)
 	g_storageTex[svDispatchThreadId.xy] = RVec4(outColor, 0.0);
 	g_tonemappedStorageTex[svDispatchThreadId.xy] = RVec4(tonemapped, 0.0);
 #	else
-	FragOut output;
+	PixelOut output;
 	output.m_color = outColor;
 	output.m_tonemappedColor = tonemapped;
 	return output;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/Tonemap.ankiprog

@@ -6,7 +6,7 @@
 // Does tonemapping
 
 #include <AnKi/Shaders/QuadVert.hlsl>
-#if ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#if ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 #	include <AnKi/Shaders/Functions.hlsl>
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
 
@@ -55,13 +55,13 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return tonemapped;
 #	endif
 }
-#endif // ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER
+#endif // ANKI_COMPUTE_SHADER || ANKI_PIXEL_SHADER
 
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
-#pragma anki technique_end frag
+#pragma anki technique_start pixel
+#pragma anki technique_end pixel
 
 #pragma anki technique_start comp
 #pragma anki technique_end comp

AnKi/Shaders/TraditionalDeferredShading.ankiprog

@@ -14,7 +14,7 @@
 #pragma anki technique_end vert
 
 // FRAG
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/PackFunctions.hlsl>
 #include <AnKi/Shaders/LightFunctions.hlsl>
 #include <AnKi/Shaders/Include/TraditionalDeferredShadingTypes.h>
@@ -119,4 +119,4 @@ RVec3 main(VertOut input) : SV_TARGET0
 	return outColor;
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/TraditionalDeferredShadingSkybox.ankiprog

@@ -10,7 +10,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
 #include <AnKi/Shaders/Functions.hlsl>
 #include <AnKi/Shaders/Sky.hlsl>
@@ -68,4 +68,4 @@ RVec3 main(VertOut input) : SV_TARGET0
 #endif
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/Ui.ankiprog

@@ -49,7 +49,7 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
 #if TEXTURE_TYPE > 0
 SamplerState g_trilinearRepeatSampler : register(s0);
@@ -65,4 +65,4 @@ RVec4 main(VertOut input) : SV_TARGET0
 #endif
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/UiVisualizeImage.ankiprog

@@ -46,7 +46,7 @@ VertOut main(VertIn input)
 }
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 
 SamplerState g_trilinearRepeatSampler : register(s0);
 #if TEXTURE_TYPE == 0
@@ -76,4 +76,4 @@ RVec4 main(VertOut input) : SV_TARGET0
 	return RVec4(outColor, 1.0);
 }
 
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/VisualizeGBufferNormal.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/PackFunctions.hlsl>
 
 SamplerState g_nearestAnyClampSampler : register(s0);
@@ -18,4 +18,4 @@ Vec3 main(VertOut input) : SV_TARGET0
 {
 	return unpackNormalFromGBuffer(g_inTex.SampleLevel(g_nearestAnyClampSampler, input.m_uv, 0.0)) / 2.0f + 0.5f;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/VisualizeHdrRenderTarget.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/TonemappingFunctions.hlsl>
 
 SamplerState g_nearestAnyClampSampler : register(s0);
@@ -18,4 +18,4 @@ Vec3 main(VertOut input) : SV_TARGET0
 {
 	return reinhardTonemap(g_inTex.SampleLevel(g_nearestAnyClampSampler, input.m_uv, 0.0).rgb);
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/VisualizeRenderTarget.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/Common.hlsl>
 
 SamplerState g_nearestAnyClampSampler : register(s0);
@@ -19,4 +19,4 @@ Vec3 main(VertOut input) : SV_TARGET0
 	const Vec4 rgba = g_inTex.SampleLevel(g_nearestAnyClampSampler, input.m_uv, 0.0);
 	return rgba.xyz;
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Shaders/VrsSriVisualizeRenderTarget.ankiprog

@@ -8,7 +8,7 @@
 #pragma anki technique_start vert
 #pragma anki technique_end vert
 
-#pragma anki technique_start frag
+#pragma anki technique_start pixel
 #include <AnKi/Shaders/Functions.hlsl>
 
 SamplerState g_nearestAnyClampSampler : register(s0);
@@ -20,4 +20,4 @@ Vec3 main(VertOut input) : SV_TARGET0
 	const UVec2 rate = decodeVrsRate(texel);
 	return visualizeVrsRate(rate);
 }
-#pragma anki technique_end frag
+#pragma anki technique_end pixel

AnKi/Ui/Font.cpp

@@ -74,7 +74,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	texInit.m_width = width;
 	texInit.m_height = height;
 	texInit.m_format = Format::kR8G8B8A8_Unorm;
-	texInit.m_usage = TextureUsageBit::kCopyDestination | TextureUsageBit::kSrvFragment;
+	texInit.m_usage = TextureUsageBit::kCopyDestination | TextureUsageBit::kSrvPixel;
 	texInit.m_mipmapCount = 1; // No mips because it will appear blurry with trilinear filtering
 
 	m_tex = GrManager::getSingleton().newTexture(texInit);
@@ -96,7 +96,7 @@ void Font::createTexture(const void* data, U32 width, U32 height)
 	cmdb->copyBufferToTexture(BufferView(buff.get()), firstMipView);
 
 	barrier.m_previousUsage = TextureUsageBit::kCopyDestination;
-	barrier.m_nextUsage = TextureUsageBit::kSrvFragment;
+	barrier.m_nextUsage = TextureUsageBit::kSrvPixel;
 	cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 
 	cmdb->endRecording();

Tests/Gr/Gr.cpp

@@ -40,7 +40,7 @@ ANKI_TEST(Gr, Shader)
 #if 0
 	COMMON_BEGIN()
 
-	ShaderPtr shader = createShader(FRAG_MRT_SRC, ShaderType::kFragment, *g_gr);
+	ShaderPtr shader = createShader(FRAG_MRT_SRC, ShaderType::kPixel, *g_gr);
 
 	COMMON_END()
 #endif
@@ -427,7 +427,7 @@ float4 main(float4 svPosition : SV_POSITION, float2 uv : TEXCOORDS, uint svPrimI
 									  TextureUsageBit::kCopyDestination};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 		cmdb->copyBufferToTexture(BufferView(uploadBuff.get()), TextureView(tex.get(), TextureSubresourceDesc::all()));
-		barrier = {TextureView(tex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment};
+		barrier = {TextureView(tex.get(), TextureSubresourceDesc::all()), TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel};
 		cmdb->setPipelineBarrier({&barrier, 1}, {}, {});
 		cmdb->endRecording();
 		FencePtr fence;
@@ -585,7 +585,7 @@ void main()
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kAllRtvDsv;
+	init.m_usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kAllRtvDsv;
 	init.m_height = RT_HEIGHT;
 	init.m_width = RT_WIDTH;
 	init.m_mipmapCount = 1;
@@ -644,7 +644,7 @@ void main()
 			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kNone, TextureUsageBit::kRtvDsvWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
 			cmdb->beginRenderPass(fb[0].get(), {{TextureUsageBit::kRtvDsvWrite}}, {});
 			cmdb->endRenderPass();
-			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+			setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
 			cmdb->endRecording();
 			GrManager::getSingleton().submit(cmdb.get());
 		}
@@ -654,7 +654,7 @@ void main()
 		CommandBufferPtr cmdb = g_gr->newCommandBuffer(cinit);
 
 		// Draw offscreen
-		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kSrvFragment, TextureUsageBit::kRtvDsvWrite, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kSrvPixel, TextureUsageBit::kRtvDsvWrite, 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);
@@ -668,7 +668,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::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, rt, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
 		// cmdb->bindTextureAndSampler(0, 0, texView.get(), sampler.get());
 		presentBarrierA(cmdb, presentTex);
 		cmdb->beginRenderPass(dfb.get(), {TextureUsageBit::kRtvDsvWrite}, {});
@@ -970,7 +970,7 @@ ANKI_TEST(Gr, Texture)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = Format::kR8G8B8_Unorm;
-	init.m_usage = TextureUsageBit::kSrvFragment;
+	init.m_usage = TextureUsageBit::kSrvPixel;
 	init.m_height = 4;
 	init.m_width = 4;
 	init.m_mipmapCount = 2;
@@ -1005,7 +1005,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = Format::kR8G8B8_Unorm;
-	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kCopyDestination;
+	init.m_usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kCopyDestination;
 	init.m_height = 2;
 	init.m_width = 2;
 	init.m_mipmapCount = 2;
@@ -1024,7 +1024,7 @@ ANKI_TEST(Gr, DrawWithTexture)
 	init.m_width = 4;
 	init.m_height = 4;
 	init.m_mipmapCount = 3;
-	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kCopyDestination | TextureUsageBit::kGenerateMipmaps;
+	init.m_usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kCopyDestination | TextureUsageBit::kGenerateMipmaps;
 
 	TexturePtr b = g_gr->newTexture(init);
 
@@ -1045,9 +1045,9 @@ ANKI_TEST(Gr, DrawWithTexture)
 	CommandBufferPtr cmdb = g_gr->newCommandBuffer(cmdbinit);
 
 	// Set barriers
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSrvFragment, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSrvPixel, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSrvFragment, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kSrvPixel, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(0, 0, 0, 0));
 
@@ -1064,13 +1064,13 @@ ANKI_TEST(Gr, DrawWithTexture)
 	cmdb->generateMipmaps2d(g_gr->newTextureView(TextureViewInitInfo(b.get())).get());
 
 	// Set barriers
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
 
-	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 	for(U32 i = 0; i < 3; ++i)
 	{
-		setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kGenerateMipmaps, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(i, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, b, TextureUsageBit::kGenerateMipmaps, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(i, 0, 0, 0));
 	}
 
 	FencePtr fence;
@@ -1231,7 +1231,7 @@ static void drawOffscreen(GrManager& gr)
 
 	TextureInitInfo init;
 	init.m_format = COL_FORMAT;
-	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kAllRtvDsv;
+	init.m_usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kAllRtvDsv;
 	init.m_height = TEX_SIZE;
 	init.m_width = TEX_SIZE;
 	init.m_type = TextureType::k2D;
@@ -1298,9 +1298,9 @@ static void drawOffscreen(GrManager& gr)
 
 		cmdb->endRenderPass();
 
-		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
-		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kAllRtvDsv, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col0, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, col1, TextureUsageBit::kRtvDsvWrite, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, dp, TextureUsageBit::kAllRtvDsv, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 		// Draw quad
 		TexturePtr presentTex = gr.acquireNextPresentableTexture();
@@ -1387,7 +1387,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 	TextureViewInitInfo viewInit2(tex.get(), TextureSurfaceDescriptor(0, 0, 0, 0));
 	cmdb->clearTextureView(g_gr->newTextureView(viewInit2).get(), clear);
 
-	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(0, 0, 0, 0));
+	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(0, 0, 0, 0));
 
 	setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kNone, TextureUsageBit::kCopyDestination, TextureSurfaceDescriptor(1, 0, 0, 0));
 
@@ -1419,7 +1419,7 @@ ANKI_TEST(Gr, ImageLoadStore)
 		cmdb->bindShaderProgram(compProg.get());
 		cmdb->bindStorageTexture(0, 0, view.get());
 		cmdb->dispatchCompute(WIDTH / 2, HEIGHT / 2, 1);
-		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kUavCompute, TextureUsageBit::kSrvFragment, TextureSurfaceDescriptor(1, 0, 0, 0));
+		setTextureSurfaceBarrier(cmdb, tex, TextureUsageBit::kUavCompute, TextureUsageBit::kSrvPixel, TextureSurfaceDescriptor(1, 0, 0, 0));
 
 		// Present image
 		cmdb->setViewport(0, 0, WIDTH, HEIGHT);
@@ -1469,7 +1469,7 @@ ANKI_TEST(Gr, 3DTextures)
 	TextureInitInfo init;
 	init.m_depth = 1;
 	init.m_format = Format::kR8G8B8A8_Unorm;
-	init.m_usage = TextureUsageBit::kSrvFragment | TextureUsageBit::kCopyDestination;
+	init.m_usage = TextureUsageBit::kSrvPixel | TextureUsageBit::kCopyDestination;
 	init.m_height = 2;
 	init.m_width = 2;
 	init.m_mipmapCount = 2;
@@ -1501,9 +1501,9 @@ ANKI_TEST(Gr, 3DTextures)
 
 	UPLOAD_TEX_VOL(cmdb, a, TextureVolumeDescriptor(1), &mip1[0], sizeof(mip1), handle1);
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureVolumeDescriptor(0));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel, TextureVolumeDescriptor(0));
 
-	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvFragment, TextureVolumeDescriptor(1));
+	setTextureVolumeBarrier(cmdb, a, TextureUsageBit::kCopyDestination, TextureUsageBit::kSrvPixel, TextureVolumeDescriptor(1));
 
 	FencePtr fence;
 	cmdb->endRecording();
@@ -1571,7 +1571,7 @@ static RenderTargetDesc newRTDescr(CString name)
 {
 	RenderTargetDesc texInf(name);
 	texInf.m_width = texInf.m_height = 16;
-	texInf.m_usage = TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kSrvFragment;
+	texInf.m_usage = TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kSrvPixel;
 	texInf.m_format = Format::kR8G8B8A8_Unorm;
 	texInf.bake();
 	return texInf;
@@ -1590,7 +1590,7 @@ ANKI_TEST(Gr, RenderGraph)
 
 	TextureInitInfo texI("dummy");
 	texI.m_width = texI.m_height = 16;
-	texI.m_usage = TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kSrvFragment;
+	texI.m_usage = TextureUsageBit::kRtvDsvWrite | TextureUsageBit::kSrvPixel;
 	texI.m_format = Format::kR8G8B8A8_Unorm;
 	TexturePtr dummyTex = g_gr->newTexture(texI);
 
@@ -1602,10 +1602,10 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// SM to exponential SM
-	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvFragment);
+	RenderTargetHandle smExpRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvPixel);
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("ESM");
-		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(smScratchRt, TextureUsageBit::kSrvPixel);
 		pass.newTextureDependency(smExpRt, TextureUsageBit::kRtvDsvWrite);
 	}
 
@@ -1621,16 +1621,16 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// GI light
-	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvFragment);
+	RenderTargetHandle giGiLightRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvPixel);
 	for(U32 faceIdx = 0; faceIdx < 6; ++faceIdx)
 	{
 		TextureSubresourceInfo subresource(TextureSurfaceDescriptor(0, faceIdx, 0));
 
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass(String().sprintf("GI lp%u", faceIdx).toCString());
 		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kRtvDsvWrite, subresource);
-		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(giGbuffNormRt, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(giGbuffDepthRt, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(giGbuffDiffRt, TextureUsageBit::kSrvPixel);
 	}
 
 	// GI light mips
@@ -1664,7 +1664,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle halfDepthRt = descr.newRenderTarget(newRTDescr("Depth/2"));
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("HalfDepth");
-		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSrvPixel);
 		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kRtvDsvWrite);
 	}
 
@@ -1673,7 +1673,7 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("QuarterDepth");
 		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSrvPixel);
 	}
 
 	// SSAO
@@ -1681,17 +1681,17 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("SSAO main");
 		pass.newTextureDependency(ssaoRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSrvPixel);
 
 		RenderTargetHandle ssaoVBlurRt = descr.newRenderTarget(newRTDescr("SSAO tmp"));
 		GraphicsRenderPass& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
-		pass2.newTextureDependency(ssaoRt, TextureUsageBit::kSrvFragment);
+		pass2.newTextureDependency(ssaoRt, TextureUsageBit::kSrvPixel);
 		pass2.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kRtvDsvWrite);
 
 		GraphicsRenderPass& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
 		pass3.newTextureDependency(ssaoRt, TextureUsageBit::kRtvDsvWrite);
-		pass3.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kSrvFragment);
+		pass3.newTextureDependency(ssaoVBlurRt, TextureUsageBit::kSrvPixel);
 	}
 
 	// Volumetric
@@ -1699,16 +1699,16 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Vol main");
 		pass.newTextureDependency(volRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(quarterDepthRt, TextureUsageBit::kSrvPixel);
 
 		RenderTargetHandle volVBlurRt = descr.newRenderTarget(newRTDescr("Vol tmp"));
 		GraphicsRenderPass& pass2 = descr.newGraphicsRenderPass("Vol vblur");
-		pass2.newTextureDependency(volRt, TextureUsageBit::kSrvFragment);
+		pass2.newTextureDependency(volRt, TextureUsageBit::kSrvPixel);
 		pass2.newTextureDependency(volVBlurRt, TextureUsageBit::kRtvDsvWrite);
 
 		GraphicsRenderPass& pass3 = descr.newGraphicsRenderPass("Vol hblur");
 		pass3.newTextureDependency(volRt, TextureUsageBit::kRtvDsvWrite);
-		pass3.newTextureDependency(volVBlurRt, TextureUsageBit::kSrvFragment);
+		pass3.newTextureDependency(volVBlurRt, TextureUsageBit::kSrvPixel);
 	}
 
 	// Forward shading
@@ -1716,8 +1716,8 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Forward shading");
 		pass.newTextureDependency(fsRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSrvFragment | TextureUsageBit::kRtvDsvRead);
-		pass.newTextureDependency(volRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(halfDepthRt, TextureUsageBit::kSrvPixel | TextureUsageBit::kRtvDsvRead);
+		pass.newTextureDependency(volRt, TextureUsageBit::kSrvPixel);
 	}
 
 	// Light shading
@@ -1726,25 +1726,25 @@ ANKI_TEST(Gr, RenderGraph)
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Light shading");
 
 		pass.newTextureDependency(lightRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(smExpRt, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(ssaoRt, TextureUsageBit::kSrvFragment);
-		pass.newTextureDependency(fsRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(gbuffRt0, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(gbuffRt1, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(gbuffRt2, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(gbuffDepth, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(smExpRt, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(giGiLightRt, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(ssaoRt, TextureUsageBit::kSrvPixel);
+		pass.newTextureDependency(fsRt, TextureUsageBit::kSrvPixel);
 	}
 
 	// TAA
-	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvFragment);
+	RenderTargetHandle taaHistoryRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kSrvPixel);
 	RenderTargetHandle taaRt = descr.importRenderTarget(dummyTex.get(), TextureUsageBit::kNone);
 	{
 		GraphicsRenderPass& pass = descr.newGraphicsRenderPass("Temporal AA");
 
-		pass.newTextureDependency(lightRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(lightRt, TextureUsageBit::kSrvPixel);
 		pass.newTextureDependency(taaRt, TextureUsageBit::kRtvDsvWrite);
-		pass.newTextureDependency(taaHistoryRt, TextureUsageBit::kSrvFragment);
+		pass.newTextureDependency(taaHistoryRt, TextureUsageBit::kSrvPixel);
 	}
 
 	rgraph->compileNewGraph(descr, pool);

Tests/Gr/GrCommon.h

@@ -51,11 +51,11 @@ inline ShaderPtr createShader(CString src, ShaderType type, ConstWeakArray<CStri
 inline ShaderProgramPtr createVertFragProg(CString vert, CString frag, ConstWeakArray<CString> extraCompilerArgs = {})
 {
 	ShaderPtr vertS = createShader(vert, ShaderType::kVertex, extraCompilerArgs);
-	ShaderPtr fragS = createShader(frag, ShaderType::kFragment, extraCompilerArgs);
+	ShaderPtr fragS = createShader(frag, ShaderType::kPixel, extraCompilerArgs);
 
 	ShaderProgramInitInfo init;
 	init.m_graphicsShaders[ShaderType::kVertex] = vertS.get();
-	init.m_graphicsShaders[ShaderType::kFragment] = fragS.get();
+	init.m_graphicsShaders[ShaderType::kPixel] = fragS.get();
 
 	ShaderProgramPtr prog = GrManager::getSingleton().newShaderProgram(init);
 

Tests/Gr/GrMeshShaders.cpp

@@ -122,14 +122,14 @@ float3 main(VertOut input) : SV_TARGET0
 
 		ShaderProgramPtr prog;
 		{
-			ShaderPtr taskShader = createShader(taskShaderSrc, ShaderType::kTask);
+			ShaderPtr taskShader = createShader(taskShaderSrc, ShaderType::kAmplification);
 			ShaderPtr meshShader = createShader(meshShaderSrc, ShaderType::kMesh);
-			ShaderPtr fragShader = createShader(fragShaderSrc, ShaderType::kFragment);
+			ShaderPtr fragShader = createShader(fragShaderSrc, ShaderType::kPixel);
 
 			ShaderProgramInitInfo progInit("Program");
-			progInit.m_graphicsShaders[ShaderType::kTask] = taskShader.get();
+			progInit.m_graphicsShaders[ShaderType::kAmplification] = taskShader.get();
 			progInit.m_graphicsShaders[ShaderType::kMesh] = meshShader.get();
-			progInit.m_graphicsShaders[ShaderType::kFragment] = fragShader.get();
+			progInit.m_graphicsShaders[ShaderType::kPixel] = fragShader.get();
 			prog = GrManager::getSingleton().newShaderProgram(progInit);
 		}