Move VK to 1.3 and some fixes

AnKi/Gr/Common.h

@@ -228,15 +228,9 @@ public:
 	/// RT.
 	Bool m_rayTracingEnabled = false;
 
-	/// 64 bit atomics.
-	Bool m_64bitAtomics = false;
-
 	/// VRS.
 	Bool m_vrs = false;
 
-	/// Supports min/max texture filtering.
-	Bool m_samplingFilterMinMax = false;
-
 	/// Supports or not 24bit, 48bit or 96bit texture formats.
 	Bool m_unalignedBbpTextureFormats = false;
 

AnKi/Gr/Vulkan/VkBuffer.cpp

@@ -126,8 +126,7 @@ BufferImpl::~BufferImpl()
 Error BufferImpl::init(const BufferInitInfo& inf)
 {
 	ANKI_ASSERT(!isCreated());
-	const Bool exposeGpuAddress =
-		!!(getGrManagerImpl().getExtensions() & VulkanExtensions::kKHR_buffer_device_address) && !!(inf.m_usage & ~BufferUsageBit::kAllCopy);
+	const Bool exposeGpuAddress = !!(inf.m_usage & ~BufferUsageBit::kAllCopy);
 
 	PtrSize size = inf.m_size;
 	BufferMapAccessBit access = inf.m_mapAccess;
@@ -151,7 +150,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	ci.usage = convertBufferUsageBit(usage);
 	if(exposeGpuAddress)
 	{
-		ci.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+		ci.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
 	}
 	ci.queueFamilyIndexCount = getGrManagerImpl().getQueueFamilies().getSize();
 	ci.pQueueFamilyIndices = &getGrManagerImpl().getQueueFamilies()[0];
@@ -278,14 +277,14 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	// Get GPU buffer address
 	if(exposeGpuAddress)
 	{
-		VkBufferDeviceAddressInfoKHR info = {};
-		info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR;
+		VkBufferDeviceAddressInfo info = {};
+		info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
 		info.buffer = m_handle;
-		m_gpuAddress = vkGetBufferDeviceAddressKHR(getVkDevice(), &info);
+		m_gpuAddress = vkGetBufferDeviceAddress(getVkDevice(), &info);
 
 		if(m_gpuAddress == 0)
 		{
-			ANKI_VK_LOGE("vkGetBufferDeviceAddressKHR() failed");
+			ANKI_VK_LOGE("vkGetBufferDeviceAddress() failed");
 			return Error::kFunctionFailed;
 		}
 	}

AnKi/Gr/Vulkan/VkCommandBuffer.cpp

@@ -373,7 +373,7 @@ void CommandBuffer::beginRenderPass(ConstWeakArray<RenderTarget> colorRts, Rende
 		const TextureImpl& tex = static_cast<const TextureImpl&>(view.getTexture());
 
 		vkColorAttachments[i] = {};
-		vkColorAttachments[i].sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR;
+		vkColorAttachments[i].sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
 		vkColorAttachments[i].imageView = tex.getImageView(view.getSubresource());
 		vkColorAttachments[i].imageLayout = tex.computeLayout(colorRts[i].m_usage);
 		vkColorAttachments[i].loadOp = convertLoadOp(colorRts[i].m_loadOperation);
@@ -414,7 +414,7 @@ void CommandBuffer::beginRenderPass(ConstWeakArray<RenderTarget> colorRts, Rende
 		if(!!(view.getDepthStencilAspect() & DepthStencilAspectBit::kDepth))
 		{
 			vkDepthAttachment = {};
-			vkDepthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR;
+			vkDepthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
 			vkDepthAttachment.imageView = tex.getImageView(view.getSubresource());
 			vkDepthAttachment.imageLayout = tex.computeLayout(depthStencilRt->m_usage);
 			vkDepthAttachment.loadOp = convertLoadOp(depthStencilRt->m_loadOperation);
@@ -428,7 +428,7 @@ void CommandBuffer::beginRenderPass(ConstWeakArray<RenderTarget> colorRts, Rende
 		if(!!(view.getDepthStencilAspect() & DepthStencilAspectBit::kStencil) && getFormatInfo(tex.getFormat()).isStencil())
 		{
 			vkStencilAttachment = {};
-			vkStencilAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR;
+			vkStencilAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
 			vkStencilAttachment.imageView = tex.getImageView(view.getSubresource());
 			vkStencilAttachment.imageLayout = tex.computeLayout(depthStencilRt->m_usage);
 			vkStencilAttachment.loadOp = convertLoadOp(depthStencilRt->m_stencilLoadOperation);
@@ -487,7 +487,7 @@ void CommandBuffer::beginRenderPass(ConstWeakArray<RenderTarget> colorRts, Rende
 	}
 
 	// Finaly
-	vkCmdBeginRenderingKHR(self.m_handle, &info);
+	vkCmdBeginRendering(self.m_handle, &info);
 }
 
 void CommandBuffer::endRenderPass()
@@ -500,7 +500,7 @@ void CommandBuffer::endRenderPass()
 #endif
 
 	self.commandCommon();
-	vkCmdEndRenderingKHR(self.m_handle);
+	vkCmdEndRendering(self.m_handle);
 }
 
 void CommandBuffer::setVrsRate(VrsRate rate)
@@ -589,8 +589,8 @@ void CommandBuffer::drawIndexedIndirectCount(PrimitiveTopology topology, const B
 
 	ANKI_ASSERT(maxDrawCount > 0 && maxDrawCount <= getGrManagerImpl().getDeviceCapabilities().m_maxDrawIndirectCount);
 
-	vkCmdDrawIndexedIndirectCountKHR(self.m_handle, argBufferImpl.getHandle(), argBuffer.getOffset(), countBufferImpl.getHandle(),
-									 countBuffer.getOffset(), maxDrawCount, argBufferStride);
+	vkCmdDrawIndexedIndirectCount(self.m_handle, argBufferImpl.getHandle(), argBuffer.getOffset(), countBufferImpl.getHandle(),
+								  countBuffer.getOffset(), maxDrawCount, argBufferStride);
 }
 
 void CommandBuffer::drawIndirectCount(PrimitiveTopology topology, const BufferView& argBuffer, U32 argBufferStride, const BufferView& countBuffer,
@@ -617,8 +617,8 @@ void CommandBuffer::drawIndirectCount(PrimitiveTopology topology, const BufferVi
 
 	ANKI_ASSERT(maxDrawCount > 0 && maxDrawCount <= getGrManagerImpl().getDeviceCapabilities().m_maxDrawIndirectCount);
 
-	vkCmdDrawIndirectCountKHR(self.m_handle, argBufferImpl.getHandle(), argBuffer.getOffset(), countBufferImpl.getHandle(), countBuffer.getOffset(),
-							  maxDrawCount, argBufferStride);
+	vkCmdDrawIndirectCount(self.m_handle, argBufferImpl.getHandle(), argBuffer.getOffset(), countBufferImpl.getHandle(), countBuffer.getOffset(),
+						   maxDrawCount, argBufferStride);
 }
 
 void CommandBuffer::drawMeshTasks(U32 groupCountX, U32 groupCountY, U32 groupCountZ)

AnKi/Gr/Vulkan/VkCommon.h

@@ -48,41 +48,26 @@ class GrManagerImpl;
 ANKI_PURE GrManagerImpl& getGrManagerImpl();
 ANKI_PURE VkDevice getVkDevice();
 
-enum class VulkanExtensions : U64
+enum class VulkanExtensions : U32
 {
 	kNone = 0,
 	kKHR_wayland_surface = 1u << 1u,
-	kKHR_win32_surface = 1u << 3u,
-	kKHR_android_surface = 1u << 4u,
-	kEXT_headless_surface = 1u << 5u,
-	kKHR_swapchain = 1u << 6u,
-	kKHR_surface = 1u << 7u,
-	kEXT_debug_utils = 1u << 8u,
-	kAMD_rasterization_order = 1u << 10u,
-	kKHR_ray_tracing = 1u << 11u,
-	kKHR_pipeline_executable_properties = 1u << 12u,
-	kEXT_descriptor_indexing = 1u << 13u,
-	kKHR_buffer_device_address = 1u << 14u,
-	kEXT_scalar_block_layout = 1u << 15u,
-	kKHR_timeline_semaphore = 1u << 16u,
-	kKHR_shader_float16_int8 = 1u << 17u,
-	kKHR_shader_atomic_int64 = 1u << 18u,
-	kKHR_spirv_1_4 = 1u << 19u,
-	kKHR_shader_float_controls = 1u << 20u,
-	kKHR_sampler_filter_min_max = 1u << 21u,
-	kKHR_create_renderpass_2 = 1u << 22u,
-	kKHR_fragment_shading_rate = 1u << 23u,
-	kEXT_astc_decode_mode = 1u << 24u,
-	kEXT_texture_compression_astc_hdr = 1u << 25u,
-	kNVX_binary_import = 1u << 26u,
-	kNVX_image_view_handle = 1u << 27u,
-	kKHR_push_descriptor = 1u << 28u,
-	kKHR_maintenance_4 = 1u << 29u,
-	kKHR_draw_indirect_count = 1u << 30u,
-	kEXT_mesh_shader = 1u << 31u,
-	kEXT_host_query_reset = 1_U64 << 32_U64,
-	kKHR_fragment_shader_barycentric = 1_U64 << 33_U64,
-	kKHR_dynamic_rendering = 1_U64 << 34_U64,
+	kKHR_win32_surface = 1u << 2u,
+	kKHR_android_surface = 1u << 3u,
+	kEXT_headless_surface = 1u << 4u,
+	kKHR_swapchain = 1u << 5u,
+	kKHR_surface = 1u << 6u,
+	kEXT_debug_utils = 1u << 7u,
+	kKHR_ray_tracing = 1u << 8u,
+	kKHR_pipeline_executable_properties = 1u << 9u,
+	kKHR_fragment_shading_rate = 1u << 10u,
+	kEXT_astc_decode_mode = 1u << 11u,
+	kEXT_texture_compression_astc_hdr = 1u << 12u,
+	kNVX_binary_import = 1u << 13u,
+	kNVX_image_view_handle = 1u << 14u,
+	kKHR_push_descriptor = 1u << 15u,
+	kEXT_mesh_shader = 1u << 16u,
+	kKHR_fragment_shader_barycentric = 1u << 17u
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(VulkanExtensions)
 

AnKi/Gr/Vulkan/VkGpuMemoryManager.cpp

@@ -76,7 +76,7 @@ void GpuMemoryManager::destroy()
 	m_callocs.destroy();
 }
 
-void GpuMemoryManager::init(Bool exposeBufferGpuAddress)
+void GpuMemoryManager::init()
 {
 	// Print some info
 	ANKI_VK_LOGV("Initializing memory manager");
@@ -118,7 +118,7 @@ void GpuMemoryManager::init(Bool exposeBufferGpuAddress)
 		GpuMemoryManagerInterface& iface = m_callocs[memTypeIdx].getInterface();
 		iface.m_parent = this;
 		iface.m_memTypeIdx = U8(memTypeIdx);
-		iface.m_exposesBufferGpuAddress = exposeBufferGpuAddress;
+		iface.m_exposesBufferGpuAddress = true;
 
 		const U32 heapIdx = m_memoryProperties.memoryTypes[memTypeIdx].heapIndex;
 		iface.m_isDeviceMemory = !!(m_memoryProperties.memoryHeaps[heapIdx].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT);

AnKi/Gr/Vulkan/VkGpuMemoryManager.h

@@ -110,9 +110,9 @@ class GpuMemoryManager : public MakeSingleton<GpuMemoryManager>
 	friend class GpuMemoryManagerInterface;
 
 public:
-	GpuMemoryManager(Bool exposeBufferGpuAddress)
+	GpuMemoryManager()
 	{
-		init(exposeBufferGpuAddress);
+		init();
 	}
 
 	GpuMemoryManager(const GpuMemoryManager&) = delete; // Non-copyable
@@ -154,7 +154,7 @@ private:
 	Atomic<PtrSize> m_dedicatedAllocatedMemory = {0};
 	Atomic<U32> m_dedicatedAllocationCount = {0};
 
-	void init(Bool exposeBufferGpuAddress);
+	void init();
 
 	void destroy();
 };

AnKi/Gr/Vulkan/VkGrManager.cpp

@@ -430,13 +430,6 @@ Error GrManagerImpl::initInternal(const GrManagerInitInfo& init)
 			m_capabilities.m_unalignedBbpTextureFormats = false;
 		}
 
-		res = vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice, VK_FORMAT_R16G16B16_UNORM, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL,
-													   VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, &props);
-		if(res == VK_ERROR_FORMAT_NOT_SUPPORTED)
-		{
-			m_capabilities.m_unalignedBbpTextureFormats = false;
-		}
-
 		res = vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice, VK_FORMAT_R32G32B32_SFLOAT, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL,
 													   VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, &props);
 		if(res == VK_ERROR_FORMAT_NOT_SUPPORTED)
@@ -446,7 +439,7 @@ Error GrManagerImpl::initInternal(const GrManagerInitInfo& init)
 
 		if(!m_capabilities.m_unalignedBbpTextureFormats)
 		{
-			ANKI_VK_LOGV("R8G8B8, R16G16B16 and R32G32B32 image formats are not supported");
+			ANKI_VK_LOGV("R8G8B8, R32G32B32 image formats are not supported");
 		}
 	}
 
@@ -469,7 +462,7 @@ Error GrManagerImpl::initInstance()
 	// Create the instance
 	//
 	const U8 vulkanMinor = 1;
-	const U8 vulkanMajor = 1;
+	const U8 vulkanMajor = 3;
 
 	VkApplicationInfo app = {};
 	app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
@@ -743,56 +736,49 @@ Error GrManagerImpl::initInstance()
 	}
 
 	m_rtPipelineProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
-	m_accelerationStructureProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+	getPhysicalDeviceProperties2(m_rtPipelineProps);
 
 	m_devProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
-	m_devProps.pNext = &m_rtPipelineProps;
-	m_rtPipelineProps.pNext = &m_accelerationStructureProps;
-
 	vkGetPhysicalDeviceProperties2(m_physicalDevice, &m_devProps);
 
+	VkPhysicalDeviceVulkan12Properties props12 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES};
+	getPhysicalDeviceProperties2(props12);
+
+	VkPhysicalDeviceVulkan13Properties props13 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES};
+	getPhysicalDeviceProperties2(props13);
+	m_capabilities.m_minWaveSize = props13.minSubgroupSize;
+	m_capabilities.m_maxWaveSize = props13.maxSubgroupSize;
+
 	// Find vendor
 	switch(m_devProps.properties.vendorID)
 	{
 	case 0x13B5:
 		m_capabilities.m_gpuVendor = GpuVendor::kArm;
-		m_capabilities.m_minWaveSize = 16;
-		m_capabilities.m_maxWaveSize = 16;
 		break;
 	case 0x10DE:
 		m_capabilities.m_gpuVendor = GpuVendor::kNvidia;
-		m_capabilities.m_minWaveSize = 32;
-		m_capabilities.m_maxWaveSize = 32;
 		break;
 	case 0x1002:
 	case 0x1022:
 		m_capabilities.m_gpuVendor = GpuVendor::kAMD;
-		m_capabilities.m_minWaveSize = 32;
-		m_capabilities.m_maxWaveSize = 64;
 		break;
 	case 0x8086:
 		m_capabilities.m_gpuVendor = GpuVendor::kIntel;
-		m_capabilities.m_minWaveSize = 8;
-		m_capabilities.m_maxWaveSize = 32;
 		break;
 	case 0x5143:
 		m_capabilities.m_gpuVendor = GpuVendor::kQualcomm;
-		m_capabilities.m_minWaveSize = 64;
-		m_capabilities.m_maxWaveSize = 128;
 		break;
 	default:
 		m_capabilities.m_gpuVendor = GpuVendor::kUnknown;
-		// Choose something really low
-		m_capabilities.m_minWaveSize = 8;
-		m_capabilities.m_maxWaveSize = 8;
 	}
-	ANKI_VK_LOGI("GPU is %s. Vendor identified as %s", m_devProps.properties.deviceName, &kGPUVendorStrings[m_capabilities.m_gpuVendor][0]);
+	ANKI_VK_LOGI("GPU is %s. Vendor identified as %s, Driver %s", m_devProps.properties.deviceName, &kGPUVendorStrings[m_capabilities.m_gpuVendor][0],
+				 props12.driverInfo);
 
 	// Set limits
 	m_capabilities.m_constantBufferBindOffsetAlignment =
-		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minUniformBufferOffsetAlignment));
+		computeCompoundAlignment<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minUniformBufferOffsetAlignment));
 	m_capabilities.m_structuredBufferBindOffsetAlignment =
-		max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minStorageBufferOffsetAlignment));
+		computeCompoundAlignment<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minStorageBufferOffsetAlignment));
 	m_capabilities.m_structuredBufferNaturalAlignment = false;
 	m_capabilities.m_texelBufferBindOffsetAlignment = max<U32>(ANKI_SAFE_ALIGNMENT, U32(m_devProps.properties.limits.minTexelBufferOffsetAlignment));
 	m_capabilities.m_computeSharedMemorySize = m_devProps.properties.limits.maxComputeSharedMemorySize;
@@ -908,11 +894,6 @@ Error GrManagerImpl::initDevice()
 				m_extensions |= VulkanExtensions::kKHR_swapchain;
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
-			else if(extensionName == VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kAMD_rasterization_order;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
 			else if(extensionName == VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME && g_rayTracingCVar)
 			{
 				m_extensions |= VulkanExtensions::kKHR_ray_tracing;
@@ -944,56 +925,6 @@ Error GrManagerImpl::initDevice()
 			{
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
-			else if(extensionName == VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kEXT_descriptor_indexing;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_buffer_device_address;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kEXT_scalar_block_layout;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_timeline_semaphore;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_shader_float16_int8;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_shader_atomic_int64;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_SPIRV_1_4_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_spirv_1_4;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_shader_float_controls;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME && g_samplerFilterMinMaxCVar)
-			{
-				m_extensions |= VulkanExtensions::kKHR_sampler_filter_min_max;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_create_renderpass_2;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
 			else if(extensionName == VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME && g_vrsCVar)
 			{
 				m_extensions |= VulkanExtensions::kKHR_fragment_shading_rate;
@@ -1024,41 +955,16 @@ Error GrManagerImpl::initDevice()
 				m_extensions |= VulkanExtensions::kNVX_image_view_handle;
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
-			else if(extensionName == VK_KHR_MAINTENANCE_4_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_maintenance_4;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_draw_indirect_count;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
 			else if(extensionName == VK_EXT_MESH_SHADER_EXTENSION_NAME && g_meshShadersCVar)
 			{
 				m_extensions |= VulkanExtensions::kEXT_mesh_shader;
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
-			else if(extensionName == VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kEXT_host_query_reset;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
 			else if(extensionName == VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)
 			{
 				m_extensions |= VulkanExtensions::kKHR_fragment_shader_barycentric;
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
-			else if(extensionName == VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)
-			{
-				m_extensions |= VulkanExtensions::kKHR_dynamic_rendering;
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
-			else if(extensionName == VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)
-			{
-				// Want it because of dynamic_rendering
-				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
-			}
 		}
 
 		ANKI_VK_LOGI("Will enable the following device extensions:");
@@ -1072,140 +978,81 @@ Error GrManagerImpl::initDevice()
 	}
 
 	// Enable/disable generic features
-	VkPhysicalDeviceFeatures devFeatures = {};
+	VkPhysicalDeviceFeatures2 devFeatures = {};
 	{
-		VkPhysicalDeviceFeatures2 devFeatures2 = {};
-		devFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &devFeatures2);
-		devFeatures = devFeatures2.features;
-		devFeatures.robustBufferAccess = (g_validationCVar && devFeatures.robustBufferAccess) ? true : false;
-		ANKI_VK_LOGI("Robust buffer access is %s", (devFeatures.robustBufferAccess) ? "enabled" : "disabled");
+		devFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &devFeatures);
+		devFeatures.features.robustBufferAccess = (g_validationCVar && devFeatures.features.robustBufferAccess) ? true : false;
+		ANKI_VK_LOGI("Robust buffer access is %s", (devFeatures.features.robustBufferAccess) ? "enabled" : "disabled");
 
-		if(devFeatures.pipelineStatisticsQuery)
+		if(devFeatures.features.pipelineStatisticsQuery)
 		{
 			m_capabilities.m_pipelineQuery = true;
 			ANKI_VK_LOGV("GPU supports pipeline statistics queries");
 		}
 
-		ci.pEnabledFeatures = &devFeatures;
+		appendPNextList(ci, &devFeatures);
 	}
 
-#if ANKI_PLATFORM_MOBILE
-	if(!(m_extensions & VulkanExtensions::kEXT_texture_compression_astc_hdr))
+	// 1.1 features
+	VkPhysicalDeviceVulkan11Features features11 = {};
 	{
-		ANKI_VK_LOGE(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-#endif
+		features11.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+		getPhysicalDevicaFeatures2(features11);
 
-	if(!(m_extensions & VulkanExtensions::kKHR_create_renderpass_2))
-	{
-		ANKI_VK_LOGE(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
+		appendPNextList(ci, &features11);
 	}
 
-	if(!!(m_extensions & VulkanExtensions::kKHR_sampler_filter_min_max))
-	{
-		m_capabilities.m_samplingFilterMinMax = true;
-	}
-	else
-	{
-		m_capabilities.m_samplingFilterMinMax = false;
-		ANKI_VK_LOGI(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME " is not supported or disabled");
+#define ANKI_ASSERT_SUPPORTED(features, feature) \
+	if(!features.feature) \
+	{ \
+		ANKI_VK_LOGE(#feature " not supported"); \
+		return Error::kFunctionFailed; \
 	}
 
-	// Descriptor indexing
-	VkPhysicalDeviceDescriptorIndexingFeatures descriptorIndexingFeatures = {};
-	if(!(m_extensions & VulkanExtensions::kEXT_descriptor_indexing))
-	{
-		ANKI_VK_LOGE(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-	else
+	// 1.2 features
+	VkPhysicalDeviceVulkan12Features features12 = {};
 	{
-		descriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;
-		getPhysicalDevicaFeatures2(descriptorIndexingFeatures);
+		features12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+		getPhysicalDevicaFeatures2(features12);
 
-		if(!descriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing
-		   || !descriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing)
-		{
-			ANKI_VK_LOGE("Non uniform indexing is not supported by the device");
-			return Error::kFunctionFailed;
-		}
+		ANKI_ASSERT_SUPPORTED(features12, descriptorIndexing)
+		ANKI_ASSERT_SUPPORTED(features12, shaderSampledImageArrayNonUniformIndexing)
+		ANKI_ASSERT_SUPPORTED(features12, shaderStorageImageArrayNonUniformIndexing)
+		ANKI_ASSERT_SUPPORTED(features12, descriptorBindingSampledImageUpdateAfterBind)
+		ANKI_ASSERT_SUPPORTED(features12, descriptorBindingStorageImageUpdateAfterBind)
+		ANKI_ASSERT_SUPPORTED(features12, descriptorBindingUpdateUnusedWhilePending)
 
-		if(!descriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind
-		   || !descriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind)
-		{
-			ANKI_VK_LOGE("Update descriptors after bind is not supported by the device");
-			return Error::kFunctionFailed;
-		}
+		ANKI_ASSERT_SUPPORTED(features12, samplerFilterMinmax)
+		ANKI_ASSERT_SUPPORTED(features12, hostQueryReset)
+		ANKI_ASSERT_SUPPORTED(features12, timelineSemaphore)
+		ANKI_ASSERT_SUPPORTED(features12, drawIndirectCount)
 
-		if(!descriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending)
-		{
-			ANKI_VK_LOGE("Update descriptors while cmd buffer is pending is not supported by the device");
-			return Error::kFunctionFailed;
-		}
+		ANKI_ASSERT_SUPPORTED(features12, bufferDeviceAddress)
+		features12.bufferDeviceAddressCaptureReplay = !!features12.bufferDeviceAddressCaptureReplay && g_debugMarkersCVar;
+		features12.bufferDeviceAddressMultiDevice = false;
 
-		appendPNextList(ci, &descriptorIndexingFeatures);
-	}
+		ANKI_ASSERT_SUPPORTED(features12, shaderFloat16)
+		ANKI_ASSERT_SUPPORTED(features12, scalarBlockLayout)
+		ANKI_ASSERT_SUPPORTED(features12, shaderBufferInt64Atomics)
 
-	// Buffer address
-	VkPhysicalDeviceBufferDeviceAddressFeaturesKHR deviceBufferFeatures = {};
-	if(!(m_extensions & VulkanExtensions::kKHR_buffer_device_address))
-	{
-		ANKI_VK_LOGW(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME " is not supported");
-	}
-	else
-	{
-		deviceBufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
-		getPhysicalDevicaFeatures2(deviceBufferFeatures);
-
-		deviceBufferFeatures.bufferDeviceAddressCaptureReplay = deviceBufferFeatures.bufferDeviceAddressCaptureReplay && g_debugMarkersCVar;
-		deviceBufferFeatures.bufferDeviceAddressMultiDevice = false;
-
-		appendPNextList(ci, &deviceBufferFeatures);
+		appendPNextList(ci, &features12);
 	}
 
-	// Scalar block layout
-	VkPhysicalDeviceScalarBlockLayoutFeaturesEXT scalarBlockLayoutFeatures = {};
-	if(!(m_extensions & VulkanExtensions::kEXT_scalar_block_layout))
+	// 1.3 features
+	VkPhysicalDeviceVulkan13Features features13 = {};
 	{
-		ANKI_VK_LOGE(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-	else
-	{
-		scalarBlockLayoutFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT;
-		getPhysicalDevicaFeatures2(scalarBlockLayoutFeatures);
+		features13.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+		getPhysicalDevicaFeatures2(features13);
 
-		if(!scalarBlockLayoutFeatures.scalarBlockLayout)
-		{
-			ANKI_VK_LOGE("Scalar block layout is not supported by the device");
-			return Error::kFunctionFailed;
-		}
-
-		appendPNextList(ci, &scalarBlockLayoutFeatures);
-	}
-
-	// Timeline semaphore
-	VkPhysicalDeviceTimelineSemaphoreFeaturesKHR timelineSemaphoreFeatures = {};
-	if(!(m_extensions & VulkanExtensions::kKHR_timeline_semaphore))
-	{
-		ANKI_VK_LOGE(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-	else
-	{
-		timelineSemaphoreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
-		getPhysicalDevicaFeatures2(timelineSemaphoreFeatures);
+		ANKI_ASSERT_SUPPORTED(features13, dynamicRendering)
+		ANKI_ASSERT_SUPPORTED(features13, maintenance4)
 
-		if(!timelineSemaphoreFeatures.timelineSemaphore)
-		{
-			ANKI_VK_LOGE("Timeline semaphores are not supported by the device");
-			return Error::kFunctionFailed;
-		}
+#if ANKI_PLATFORM_MOBILE
+		ANKI_ASSERT_SUPPORTED(features13, textureCompressionASTC_HDR)
+#endif
 
-		appendPNextList(ci, &timelineSemaphoreFeatures);
+		appendPNextList(ci, &features13);
 	}
 
 	// Set RT features
@@ -1260,38 +1107,6 @@ Error GrManagerImpl::initDevice()
 		appendPNextList(ci, &pplineExecutablePropertiesFeatures);
 	}
 
-	// F16 I8
-	VkPhysicalDeviceShaderFloat16Int8FeaturesKHR float16Int8Features = {};
-	if(!(m_extensions & VulkanExtensions::kKHR_shader_float16_int8))
-	{
-		ANKI_VK_LOGE(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-	else
-	{
-		float16Int8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR;
-		getPhysicalDevicaFeatures2(float16Int8Features);
-
-		appendPNextList(ci, &float16Int8Features);
-	}
-
-	// 64bit atomics
-	VkPhysicalDeviceShaderAtomicInt64FeaturesKHR atomicInt64Features = {};
-	if(!(m_extensions & VulkanExtensions::kKHR_shader_atomic_int64))
-	{
-		ANKI_VK_LOGW(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME " is not supported or disabled");
-		m_capabilities.m_64bitAtomics = false;
-	}
-	else
-	{
-		m_capabilities.m_64bitAtomics = true;
-
-		atomicInt64Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR;
-		getPhysicalDevicaFeatures2(atomicInt64Features);
-
-		appendPNextList(ci, &atomicInt64Features);
-	}
-
 	// VRS
 	VkPhysicalDeviceFragmentShadingRateFeaturesKHR fragmentShadingRateFeatures = {};
 	if(!(m_extensions & VulkanExtensions::kKHR_fragment_shading_rate))
@@ -1372,27 +1187,6 @@ Error GrManagerImpl::initDevice()
 		ANKI_VK_LOGI(VK_EXT_MESH_SHADER_EXTENSION_NAME " is not supported or disabled ");
 	}
 
-	// Host query reset
-	VkPhysicalDeviceHostQueryResetFeaturesEXT hostQueryResetFeatures = {};
-	if(!!(m_extensions & VulkanExtensions::kEXT_host_query_reset))
-	{
-		hostQueryResetFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
-		getPhysicalDevicaFeatures2(hostQueryResetFeatures);
-
-		if(hostQueryResetFeatures.hostQueryReset == false)
-		{
-			ANKI_VK_LOGE("VkPhysicalDeviceHostQueryResetFeaturesEXT::hostQueryReset is false");
-			return Error::kFunctionFailed;
-		}
-
-		appendPNextList(ci, &hostQueryResetFeatures);
-	}
-	else
-	{
-		ANKI_VK_LOGE(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-
 	// Barycentrics
 	VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR baryFeatures = {};
 	if(!!(m_extensions & VulkanExtensions::kKHR_fragment_shader_barycentric))
@@ -1411,52 +1205,6 @@ Error GrManagerImpl::initDevice()
 		m_capabilities.m_barycentrics = true;
 	}
 
-	VkPhysicalDeviceMaintenance4FeaturesKHR maintenance4Features = {};
-	if(!!(m_extensions & VulkanExtensions::kKHR_maintenance_4))
-	{
-		maintenance4Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR;
-		maintenance4Features.maintenance4 = true;
-		appendPNextList(ci, &maintenance4Features);
-	}
-
-	if(!(m_extensions & VulkanExtensions::kKHR_draw_indirect_count) || m_capabilities.m_maxDrawIndirectCount < kMaxU32)
-	{
-		ANKI_VK_LOGE(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME " not supported or too small maxDrawIndirectCount");
-		return Error::kFunctionFailed;
-	}
-
-	if(!(m_extensions & VulkanExtensions::kKHR_spirv_1_4))
-	{
-		ANKI_VK_LOGE(VK_KHR_SPIRV_1_4_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-
-	if(!(m_extensions & VulkanExtensions::kKHR_shader_float_controls))
-	{
-		ANKI_VK_LOGE(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-
-	VkPhysicalDeviceDynamicRenderingFeatures dynRenderingFeatures = {};
-	if(!(m_extensions & VulkanExtensions::kKHR_dynamic_rendering))
-	{
-		ANKI_VK_LOGE(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME " is not supported");
-		return Error::kFunctionFailed;
-	}
-	else
-	{
-		dynRenderingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR;
-		getPhysicalDevicaFeatures2(dynRenderingFeatures);
-
-		if(!dynRenderingFeatures.dynamicRendering)
-		{
-			ANKI_VK_LOGE("VkPhysicalDeviceDynamicRenderingFeatures::dynamicRendering is false");
-			return Error::kFunctionFailed;
-		}
-
-		appendPNextList(ci, &dynRenderingFeatures);
-	}
-
 	ANKI_VK_CHECK(vkCreateDevice(m_physicalDevice, &ci, nullptr, &m_device));
 
 	return Error::kNone;
@@ -1478,7 +1226,7 @@ Error GrManagerImpl::initMemory()
 					 ANKI_FORMAT_U32(m_memoryProperties.memoryTypes[i].propertyFlags));
 	}
 
-	GpuMemoryManager::allocateSingleton(!!(m_extensions & VulkanExtensions::kKHR_buffer_device_address));
+	GpuMemoryManager::allocateSingleton();
 
 	return Error::kNone;
 }

AnKi/Gr/Vulkan/VkGrManager.h

@@ -149,7 +149,6 @@ private:
 	Mutex m_globalMtx;
 
 	VkPhysicalDeviceProperties2 m_devProps = {};
-	VkPhysicalDeviceAccelerationStructurePropertiesKHR m_accelerationStructureProps = {};
 	VkPhysicalDeviceRayTracingPipelinePropertiesKHR m_rtPipelineProps = {};
 
 	VkDebugUtilsMessengerEXT m_debugUtilsMessager = VK_NULL_HANDLE;

AnKi/Gr/Vulkan/VkQueryFactory.cpp

@@ -71,7 +71,7 @@ Error QueryFactory::newQuery(MicroQuery& handle)
 			handle.m_queryIndex = i;
 			handle.m_chunk = chunk;
 
-			vkResetQueryPoolEXT(getVkDevice(), chunk->m_pool, handle.m_queryIndex, 1);
+			vkResetQueryPool(getVkDevice(), chunk->m_pool, handle.m_queryIndex, 1);
 
 			break;
 		}

AnKi/Gr/Vulkan/VkSampler.cpp

@@ -33,7 +33,6 @@ Error MicroSampler::init(const SamplerInitInfo& inf)
 	else
 	{
 		ANKI_ASSERT(inf.m_minMagFilter == SamplingFilter::kMax || inf.m_minMagFilter == SamplingFilter::kMin);
-		ANKI_ASSERT(getGrManagerImpl().getDeviceCapabilities().m_samplingFilterMinMax);
 		ci.minFilter = VK_FILTER_LINEAR;
 	}
 

AnKi/Gr/Vulkan/VkSemaphoreFactory.cpp

@@ -52,7 +52,7 @@ Bool MicroSemaphore::clientWait(Second seconds)
 	const U64 ns = U64(nsf);
 
 	VkResult res;
-	ANKI_VK_CHECKF(res = vkWaitSemaphoresKHR(getVkDevice(), &waitInfo, ns));
+	ANKI_VK_CHECKF(res = vkWaitSemaphores(getVkDevice(), &waitInfo, ns));
 
 	return res != VK_TIMEOUT;
 }

AnKi/Renderer/Sky.cpp

@@ -21,8 +21,7 @@ Error GeneratedSky::init()
 
 	const TextureUsageBit usage = TextureUsageBit::kAllCompute;
 	const TextureUsageBit initialUsage = TextureUsageBit::kSrvCompute;
-	const Format formatB =
-		(GrManager::getSingleton().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR16G16B16_Unorm : Format::kR16G16B16A16_Unorm;
+	const Format formatB = getRenderer().getHdrFormat();
 
 	m_transmittanceLut = getRenderer().createAndClearRenderTarget(
 		getRenderer().create2DRenderTargetInitInfo(kTransmittanceLutSize.x(), kTransmittanceLutSize.y(), formatB, usage, "SkyTransmittanceLut"),

AnKi/Renderer/TemporalUpscaler.cpp

@@ -24,22 +24,26 @@ Error TemporalUpscaler::init()
 		return Error::kNone;
 	}
 
-	if(!GrManager::getSingleton().getDeviceCapabilities().m_dlss)
+	if(GrManager::getSingleton().getDeviceCapabilities().m_dlss)
 	{
-		ANKI_R_LOGE("Can't do upscaling without a GR upscaler");
-		return Error::kFunctionFailed;
-	}
 
-	GrUpscalerInitInfo inf;
-	inf.m_sourceTextureResolution = getRenderer().getInternalResolution();
-	inf.m_targetTextureResolution = getRenderer().getPostProcessResolution();
-	inf.m_upscalerType = GrUpscalerType::kDlss2;
-	inf.m_qualityMode = GrUpscalerQualityMode(g_dlssQualityCVar - 1);
+		GrUpscalerInitInfo inf;
+		inf.m_sourceTextureResolution = getRenderer().getInternalResolution();
+		inf.m_targetTextureResolution = getRenderer().getPostProcessResolution();
+		inf.m_upscalerType = GrUpscalerType::kDlss2;
+		inf.m_qualityMode = GrUpscalerQualityMode(g_dlssQualityCVar - 1);
+
+		m_grUpscaler = GrManager::getSingleton().newGrUpscaler(inf);
+	}
+	else
+	{
+		ANKI_R_LOGW("No support of temporal upscaler. Will just blit instead");
 
-	m_grUpscaler = GrManager::getSingleton().newGrUpscaler(inf);
+		ANKI_CHECK(loadShaderProgram("ShaderBinaries/Blit.ankiprogbin", m_blitProg, m_blitGrProg));
+	}
 
-	m_rtDesc = getRenderer().create2DRenderTargetDescription(
-		getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y(), getRenderer().getHdrFormat(), "Upscaled (DLSS)");
+	m_rtDesc = getRenderer().create2DRenderTargetDescription(getRenderer().getPostProcessResolution().x(),
+															 getRenderer().getPostProcessResolution().y(), getRenderer().getHdrFormat(), "Upscaled");
 	m_rtDesc.bake();
 
 	return Error::kNone;
@@ -52,40 +56,98 @@ void TemporalUpscaler::populateRenderGraph(RenderingContext& ctx)
 
 	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDesc);
 
-	NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("DLSS");
-
-	// DLSS says input textures in sampled state and out as storage image
-	const TextureUsageBit readUsage = TextureUsageBit::kAllSrv & TextureUsageBit::kAllCompute;
-	const TextureUsageBit writeUsage = TextureUsageBit::kAllUav & TextureUsageBit::kAllCompute;
-
-	pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
-	pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
-	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), readUsage,
-							  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
-	pass.newTextureDependency(m_runCtx.m_rt, writeUsage);
-
-	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
-		ANKI_TRACE_SCOPED_EVENT(TemporalUpscaler);
-
-		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
-
-		const Vec2 srcRes(getRenderer().getInternalResolution());
-		const Bool reset = getRenderer().getFrameCount() == 0;
-		const Vec2 mvScale = srcRes; // UV space to Pixel space factor
-		// In [-texSize / 2, texSize / 2] -> sub-pixel space {-0.5, 0.5}
-		const Vec2 jitterOffset = ctx.m_matrices.m_jitter.getTranslationPart().xy() * srcRes * 0.5f;
-
-		const TextureView srcView = rgraphCtx.createTextureView(getRenderer().getLightShading().getRt(), TextureSubresourceDesc::firstSurface());
-		const TextureView motionVectorsView =
-			rgraphCtx.createTextureView(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureSubresourceDesc::firstSurface());
-		const TextureView depthView =
-			rgraphCtx.createTextureView(getRenderer().getGBuffer().getDepthRt(), TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
-		const TextureView exposureView =
-			rgraphCtx.createTextureView(getRenderer().getTonemapping().getExposureAndAvgLuminanceRt(), TextureSubresourceDesc::firstSurface());
-		const TextureView dstView = rgraphCtx.createTextureView(m_runCtx.m_rt, TextureSubresourceDesc::firstSurface());
-
-		cmdb.upscale(m_grUpscaler.get(), srcView, dstView, motionVectorsView, depthView, exposureView, reset, jitterOffset, mvScale);
-	});
+	if(m_grUpscaler.isCreated())
+	{
+		NonGraphicsRenderPass& pass = ctx.m_renderGraphDescr.newNonGraphicsRenderPass("DLSS");
+
+		// DLSS says input textures in sampled state and out as storage image
+		const TextureUsageBit readUsage = TextureUsageBit::kAllSrv & TextureUsageBit::kAllCompute;
+		const TextureUsageBit writeUsage = TextureUsageBit::kAllUav & TextureUsageBit::kAllCompute;
+
+		pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
+		pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
+		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), readUsage,
+								  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
+		pass.newTextureDependency(m_runCtx.m_rt, writeUsage);
+
+		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
+			ANKI_TRACE_SCOPED_EVENT(TemporalUpscaler);
+
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+
+			const Vec2 srcRes(getRenderer().getInternalResolution());
+			const Bool reset = getRenderer().getFrameCount() == 0;
+			const Vec2 mvScale = srcRes; // UV space to Pixel space factor
+			// In [-texSize / 2, texSize / 2] -> sub-pixel space {-0.5, 0.5}
+			const Vec2 jitterOffset = ctx.m_matrices.m_jitter.getTranslationPart().xy() * srcRes * 0.5f;
+
+			const TextureView srcView = rgraphCtx.createTextureView(getRenderer().getLightShading().getRt(), TextureSubresourceDesc::firstSurface());
+			const TextureView motionVectorsView =
+				rgraphCtx.createTextureView(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureSubresourceDesc::firstSurface());
+			const TextureView depthView = rgraphCtx.createTextureView(getRenderer().getGBuffer().getDepthRt(),
+																	  TextureSubresourceDesc::firstSurface(DepthStencilAspectBit::kDepth));
+			const TextureView exposureView =
+				rgraphCtx.createTextureView(getRenderer().getTonemapping().getExposureAndAvgLuminanceRt(), TextureSubresourceDesc::firstSurface());
+			const TextureView dstView = rgraphCtx.createTextureView(m_runCtx.m_rt, TextureSubresourceDesc::firstSurface());
+
+			cmdb.upscale(m_grUpscaler.get(), srcView, dstView, motionVectorsView, depthView, exposureView, reset, jitterOffset, mvScale);
+		});
+	}
+	else
+	{
+		const Bool preferCompute = g_preferComputeCVar;
+
+		TextureUsageBit readUsage;
+		TextureUsageBit writeUsage;
+		if(preferCompute)
+		{
+			readUsage = TextureUsageBit::kSrvCompute;
+			writeUsage = TextureUsageBit::kUavCompute;
+		}
+		else
+		{
+			readUsage = TextureUsageBit::kSrvPixel;
+			writeUsage = TextureUsageBit::kRtvDsvWrite;
+		}
+
+		RenderPassBase* ppass;
+		if(preferCompute)
+		{
+			NonGraphicsRenderPass& pass = rgraph.newNonGraphicsRenderPass("Upscaling");
+			ppass = &pass;
+		}
+		else
+		{
+			GraphicsRenderPass& pass = rgraph.newGraphicsRenderPass("Upscaling");
+			pass.setRenderpassInfo({GraphicsRenderPassTargetDesc(m_runCtx.m_rt)});
+			ppass = &pass;
+		}
+
+		ppass->newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
+		ppass->newTextureDependency(m_runCtx.m_rt, writeUsage);
+
+		ppass->setWork([this](RenderPassWorkContext& rgraphCtx) {
+			ANKI_TRACE_SCOPED_EVENT(TemporalUpscaler);
+
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+
+			rgraphCtx.bindSrv(0, 0, getRenderer().getLightShading().getRt());
+			cmdb.bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp.get());
+
+			const Bool preferCompute = g_preferComputeCVar;
+
+			if(preferCompute)
+			{
+				rgraphCtx.bindUav(0, 0, m_runCtx.m_rt);
+
+				dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
+			}
+			else
+			{
+				drawQuad(cmdb);
+			}
+		});
+	}
 }
 
 } // end namespace anki

AnKi/Renderer/TemporalUpscaler.h

@@ -38,6 +38,9 @@ private:
 
 	RenderTargetDesc m_rtDesc;
 
+	ShaderProgramResourcePtr m_blitProg;
+	ShaderProgramPtr m_blitGrProg;
+
 	class
 	{
 	public:

AnKi/Renderer/Utils/HzbGenerator.cpp

@@ -35,7 +35,6 @@ static constexpr U16 kBoxIndices[] = {1, 2, 5, 2, 6, 5, 0, 4, 3, 4, 7, 3, 3, 7,
 
 Error HzbGenerator::init()
 {
-	if(GrManager::getSingleton().getDeviceCapabilities().m_samplingFilterMinMax)
 	{
 		SamplerInitInfo sinit("HzbReductionMax");
 		sinit.m_addressing = SamplingAddressing::kClamp;

AnKi/Shaders/Reflections.ankiprog

@@ -836,6 +836,11 @@ void reconstructCheckerboardBlack(IVec2 svGroupThreadId, F32 refDepth, inout Vec
 		refHitPos = g_hitPosAndDepthTex[checkerboardCoord].xyz;
 		g_hitPosAndDepth[svGroupThreadId.x][svGroupThreadId.y] = Vec4(refHitPos, refDepth);
 	}
+	else
+	{
+		g_colorAndPdf[svGroupThreadId.x][svGroupThreadId.y] = 0.0;
+		g_hitPosAndDepth[svGroupThreadId.x][svGroupThreadId.y] = Vec4(0.0, 0.0, 0.0, refDepth);
+	}
 
 	GroupMemoryBarrierWithGroupSync();