Downgrade to Vulkan 1.1 :(

AnKi/Gr/ConfigDefs.h

@@ -13,5 +13,5 @@ ANKI_CONFIG_OPTION(gr_rayTracing, 0, 0, 1, "Try enabling ray tracing")
 
 // Vulkan
 ANKI_CONFIG_OPTION(gr_diskShaderCacheMaxSize, 128_MB, 1_MB, 1_GB)
-ANKI_CONFIG_OPTION(gr_vkminor, 2, 2, 2)
+ANKI_CONFIG_OPTION(gr_vkminor, 1, 1, 1)
 ANKI_CONFIG_OPTION(gr_vkmajor, 1, 1, 1)

AnKi/Gr/Vulkan/BufferImpl.cpp

@@ -27,7 +27,7 @@ BufferImpl::~BufferImpl()
 Error BufferImpl::init(const BufferInitInfo& inf)
 {
 	ANKI_ASSERT(!isCreated());
-	const Bool exposeGpuAddress = !!(getGrManagerImpl().getExtensions() & VulkanExtensions::KHR_RAY_TRACING)
+	const Bool exposeGpuAddress = !!(getGrManagerImpl().getExtensions() & VulkanExtensions::KHR_BUFFER_DEVICE_ADDRESS)
 								  && !!(inf.m_usage & ~BufferUsageBit::ALL_TRANSFER);
 
 	PtrSize size = inf.m_size;
@@ -47,7 +47,7 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	ci.usage = convertBufferUsageBit(usage);
 	if(exposeGpuAddress)
 	{
-		ci.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
+		ci.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
 	}
 	ci.sharingMode = VK_SHARING_MODE_CONCURRENT;
 	ci.queueFamilyIndexCount = getGrManagerImpl().getQueueFamilies().getSize();
@@ -164,14 +164,14 @@ Error BufferImpl::init(const BufferInitInfo& inf)
 	// Get GPU buffer address
 	if(exposeGpuAddress)
 	{
-		VkBufferDeviceAddressInfo info = {};
-		info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
+		VkBufferDeviceAddressInfoKHR info = {};
+		info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR;
 		info.buffer = m_handle;
-		m_gpuAddress = vkGetBufferDeviceAddress(getDevice(), &info);
+		m_gpuAddress = vkGetBufferDeviceAddressKHR(getDevice(), &info);
 
 		if(m_gpuAddress == 0)
 		{
-			ANKI_VK_LOGE("vkGetBufferDeviceAddress() failed");
+			ANKI_VK_LOGE("vkGetBufferDeviceAddressKHR() failed");
 			return Error::FUNCTION_FAILED;
 		}
 	}

AnKi/Gr/Vulkan/Common.h

@@ -57,7 +57,7 @@ enum class DescriptorType : U8
 	COUNT
 };
 
-enum class VulkanExtensions : U16
+enum class VulkanExtensions : U32
 {
 	NONE = 0,
 	KHR_XCB_SURFACE = 1 << 1,
@@ -71,7 +71,13 @@ enum class VulkanExtensions : U16
 	AMD_SHADER_INFO = 1 << 9,
 	AMD_RASTERIZATION_ORDER = 1 << 10,
 	KHR_RAY_TRACING = 1 << 11,
-	PIPELINE_EXECUTABLE_PROPERTIES = 1 << 12,
+	KHR_PIPELINE_EXECUTABLE_PROPERTIES = 1 << 12,
+	EXT_DESCRIPTOR_INDEXING = 1 << 13,
+	KHR_BUFFER_DEVICE_ADDRESS = 1 << 14,
+	EXT_SCALAR_BLOCK_LAYOUT = 1 << 15,
+	KHR_TIMELINE_SEMAPHORE = 1 << 16,
+	KHR_SHADER_FLOAT16_INT8 = 1 << 17,
+	KHR_SHADER_ATOMIC_INT64 = 1 << 18,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(VulkanExtensions)
 

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -609,7 +609,7 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 			else if(extensionName == VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME
 					&& init.m_config->getBool("core_displayStats"))
 			{
-				m_extensions |= VulkanExtensions::PIPELINE_EXECUTABLE_PROPERTIES;
+				m_extensions |= VulkanExtensions::KHR_PIPELINE_EXECUTABLE_PROPERTIES;
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
 			else if(extensionName == VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME
@@ -617,6 +617,36 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 			{
 				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
 			}
+			else if(extensionName == VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::EXT_DESCRIPTOR_INDEXING;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
+			else if(extensionName == VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::KHR_BUFFER_DEVICE_ADDRESS;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
+			else if(extensionName == VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::EXT_SCALAR_BLOCK_LAYOUT;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
+			else if(extensionName == VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::KHR_TIMELINE_SEMAPHORE;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
+			else if(extensionName == VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::KHR_SHADER_FLOAT16_INT8;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
+			else if(extensionName == VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)
+			{
+				m_extensions |= VulkanExtensions::KHR_SHADER_ATOMIC_INT64;
+				extensionsToEnable[extensionsToEnableCount++] = extensionName.cstr();
+			}
 		}
 
 		ANKI_VK_LOGI("Will enable the following device extensions:");
@@ -642,100 +672,116 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 		ci.pEnabledFeatures = &m_devFeatures;
 	}
 
-	// Enable 1.1 features
+	// Descriptor indexing
+	if(!(m_extensions & VulkanExtensions::EXT_DESCRIPTOR_INDEXING))
 	{
-		m_11Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
-
-		VkPhysicalDeviceFeatures2 features = {};
-		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-		features.pNext = &m_11Features;
-		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
-
-		if(!m_11Features.storageBuffer16BitAccess || !m_11Features.uniformAndStorageBuffer16BitAccess)
-		{
-			ANKI_VK_LOGE("16bit buffer access is not supported");
-			return Error::FUNCTION_FAILED;
-		}
-
-		// Disable a few things
-		m_11Features.storagePushConstant16 = false; // Because AMD doesn't support it
-		m_11Features.protectedMemory = false;
-		m_11Features.multiview = false;
-		m_11Features.multiviewGeometryShader = false;
-		m_11Features.multiviewTessellationShader = false;
-		m_11Features.samplerYcbcrConversion = false;
-
-		m_11Features.pNext = const_cast<void*>(ci.pNext);
-		ci.pNext = &m_11Features;
+		ANKI_VK_LOGE("Descriptor indexing is not supported");
+		return Error::FUNCTION_FAILED;
 	}
-
-	// Enable a few 1.2 features
+	else
 	{
-		m_12Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+		m_descriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;
 
 		VkPhysicalDeviceFeatures2 features = {};
 		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-		features.pNext = &m_12Features;
-
+		features.pNext = &m_descriptorIndexingFeatures;
 		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
 
-		// Descriptor indexing
-		if(!m_12Features.shaderSampledImageArrayNonUniformIndexing
-		   || !m_12Features.shaderStorageImageArrayNonUniformIndexing)
+		if(!m_descriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing
+		   || !m_descriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing)
 		{
 			ANKI_VK_LOGE("Non uniform indexing is not supported by the device");
 			return Error::FUNCTION_FAILED;
 		}
 
-		if(!m_12Features.descriptorBindingSampledImageUpdateAfterBind
-		   || !m_12Features.descriptorBindingStorageImageUpdateAfterBind)
+		if(!m_descriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind
+		   || !m_descriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind)
 		{
 			ANKI_VK_LOGE("Update descriptors after bind is not supported by the device");
 			return Error::FUNCTION_FAILED;
 		}
 
-		if(!m_12Features.descriptorBindingUpdateUnusedWhilePending)
+		if(!m_descriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending)
 		{
 			ANKI_VK_LOGE("Update descriptors while cmd buffer is pending is not supported by the device");
 			return Error::FUNCTION_FAILED;
 		}
 
-		// Buffer address
-		if(!!(m_extensions & VulkanExtensions::KHR_RAY_TRACING))
-		{
-			if(!m_12Features.bufferDeviceAddress)
-			{
-				ANKI_VK_LOGE("Buffer device address is not supported by the device");
-				return Error::FUNCTION_FAILED;
-			}
+		m_descriptorIndexingFeatures.pNext = const_cast<void*>(ci.pNext);
+		ci.pNext = &m_descriptorIndexingFeatures;
+	}
 
-			m_12Features.bufferDeviceAddressCaptureReplay =
-				m_12Features.bufferDeviceAddressCaptureReplay && init.m_config->getBool("gr_debugMarkers");
-			m_12Features.bufferDeviceAddressMultiDevice = false;
-		}
-		else
-		{
-			m_12Features.bufferDeviceAddress = false;
-			m_12Features.bufferDeviceAddressCaptureReplay = false;
-			m_12Features.bufferDeviceAddressMultiDevice = false;
-		}
+	// Buffer address
+	if(!(m_extensions & VulkanExtensions::KHR_BUFFER_DEVICE_ADDRESS))
+	{
+		ANKI_VK_LOGE("Device buffer access extension is not supported");
+		return Error::FUNCTION_FAILED;
+	}
+	else
+	{
+		m_deviceBufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
+
+		VkPhysicalDeviceFeatures2 features = {};
+		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+		features.pNext = &m_deviceBufferFeatures;
+		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
 
-		// Scalar block layout
-		if(!m_12Features.scalarBlockLayout)
+		m_deviceBufferFeatures.bufferDeviceAddressCaptureReplay =
+			m_deviceBufferFeatures.bufferDeviceAddressCaptureReplay && init.m_config->getBool("gr_debugMarkers");
+		m_deviceBufferFeatures.bufferDeviceAddressMultiDevice = false;
+
+		m_deviceBufferFeatures.pNext = const_cast<void*>(ci.pNext);
+		ci.pNext = &m_deviceBufferFeatures;
+	}
+
+	// Scalar block layout
+	if(!(m_extensions & VulkanExtensions::EXT_SCALAR_BLOCK_LAYOUT))
+	{
+		ANKI_VK_LOGE("Scalar block layout extension is not supported");
+		return Error::FUNCTION_FAILED;
+	}
+	else
+	{
+		m_scalarBlockLayout.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT;
+
+		VkPhysicalDeviceFeatures2 features = {};
+		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+		features.pNext = &m_scalarBlockLayout;
+		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
+
+		if(!m_scalarBlockLayout.scalarBlockLayout)
 		{
 			ANKI_VK_LOGE("Scalar block layout is not supported by the device");
 			return Error::FUNCTION_FAILED;
 		}
 
-		// Timeline semaphores
-		if(!m_12Features.timelineSemaphore)
+		m_scalarBlockLayout.pNext = const_cast<void*>(ci.pNext);
+		ci.pNext = &m_scalarBlockLayout;
+	}
+
+	// Timeline semaphore
+	if(!(m_extensions & VulkanExtensions::KHR_TIMELINE_SEMAPHORE))
+	{
+		ANKI_VK_LOGE("Timeline semaphore extension is not supported");
+		return Error::FUNCTION_FAILED;
+	}
+	else
+	{
+		m_timelineSemaphoreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
+
+		VkPhysicalDeviceFeatures2 features = {};
+		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+		features.pNext = &m_timelineSemaphoreFeatures;
+		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
+
+		if(!m_timelineSemaphoreFeatures.timelineSemaphore)
 		{
 			ANKI_VK_LOGE("Timeline semaphores are not supported by the device");
 			return Error::FUNCTION_FAILED;
 		}
 
-		m_12Features.pNext = const_cast<void*>(ci.pNext);
-		ci.pNext = &m_12Features;
+		m_timelineSemaphoreFeatures.pNext = const_cast<void*>(ci.pNext);
+		ci.pNext = &m_timelineSemaphoreFeatures;
 	}
 
 	// Set RT features
@@ -773,7 +819,7 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 	}
 
 	// Pipeline features
-	if(!!(m_extensions & VulkanExtensions::PIPELINE_EXECUTABLE_PROPERTIES))
+	if(!!(m_extensions & VulkanExtensions::KHR_PIPELINE_EXECUTABLE_PROPERTIES))
 	{
 		m_pplineExecutablePropertiesFeatures.sType =
 			VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
@@ -783,6 +829,44 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 		ci.pNext = &m_pplineExecutablePropertiesFeatures;
 	}
 
+	// F16 I8
+	if(!(m_extensions & VulkanExtensions::KHR_SHADER_FLOAT16_INT8))
+	{
+		ANKI_VK_LOGE("FP16/Int8 extension is not supported");
+		return Error::FUNCTION_FAILED;
+	}
+	else
+	{
+		m_float16Int8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR;
+
+		VkPhysicalDeviceFeatures2 features = {};
+		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+		features.pNext = &m_float16Int8Features;
+		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
+
+		m_float16Int8Features.pNext = const_cast<void*>(ci.pNext);
+		ci.pNext = &m_float16Int8Features;
+	}
+
+	// 64bit atomics
+	if(!(m_extensions & VulkanExtensions::KHR_SHADER_ATOMIC_INT64))
+	{
+		ANKI_VK_LOGE("64bit atomics are not supported");
+		return Error::FUNCTION_FAILED;
+	}
+	else
+	{
+		m_atomicInt64Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR;
+
+		VkPhysicalDeviceFeatures2 features = {};
+		features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+		features.pNext = &m_atomicInt64Features;
+		vkGetPhysicalDeviceFeatures2(m_physicalDevice, &features);
+
+		m_atomicInt64Features.pNext = const_cast<void*>(ci.pNext);
+		ci.pNext = &m_atomicInt64Features;
+	}
+
 	ANKI_VK_CHECK(vkCreateDevice(m_physicalDevice, &ci, nullptr, &m_device));
 
 	// Get debug marker
@@ -842,7 +926,7 @@ Error GrManagerImpl::initMemory(const ConfigSet& cfg)
 	}
 
 	m_gpuMemManager.init(m_physicalDevice, m_device, getAllocator(),
-						 !!(m_extensions & VulkanExtensions::KHR_RAY_TRACING));
+						 !!(m_extensions & VulkanExtensions::KHR_BUFFER_DEVICE_ADDRESS));
 
 	return Error::NONE;
 }
@@ -1269,7 +1353,7 @@ Error GrManagerImpl::printPipelineShaderInfoInternal(VkPipeline ppline, CString
 		ANKI_CHECK(m_shaderStatsFile.flush());
 	}
 
-	if(!!(m_extensions & VulkanExtensions::PIPELINE_EXECUTABLE_PROPERTIES))
+	if(!!(m_extensions & VulkanExtensions::KHR_PIPELINE_EXECUTABLE_PROPERTIES))
 	{
 		StringListAuto log(m_alloc);
 

AnKi/Gr/Vulkan/GrManagerImpl.h

@@ -250,9 +250,13 @@ private:
 	VkPhysicalDeviceAccelerationStructureFeaturesKHR m_accelerationStructureFeatures = {};
 	VkPhysicalDeviceRayTracingPipelineFeaturesKHR m_rtPipelineFeatures = {};
 	VkPhysicalDeviceRayQueryFeaturesKHR m_rayQueryFeatures = {};
-	VkPhysicalDeviceVulkan11Features m_11Features = {};
-	VkPhysicalDeviceVulkan12Features m_12Features = {};
 	VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR m_pplineExecutablePropertiesFeatures = {};
+	VkPhysicalDeviceDescriptorIndexingFeatures m_descriptorIndexingFeatures = {};
+	VkPhysicalDeviceBufferDeviceAddressFeaturesKHR m_deviceBufferFeatures = {};
+	VkPhysicalDeviceScalarBlockLayoutFeaturesEXT m_scalarBlockLayout = {};
+	VkPhysicalDeviceTimelineSemaphoreFeaturesKHR m_timelineSemaphoreFeatures = {};
+	VkPhysicalDeviceShaderFloat16Int8FeaturesKHR m_float16Int8Features = {};
+	VkPhysicalDeviceShaderAtomicInt64FeaturesKHR m_atomicInt64Features = {};
 
 	PFN_vkDebugMarkerSetObjectNameEXT m_pfnDebugMarkerSetObjectNameEXT = nullptr;
 	PFN_vkCmdDebugMarkerBeginEXT m_pfnCmdDebugMarkerBeginEXT = nullptr;

AnKi/ShaderCompiler/Glslang.cpp

@@ -318,8 +318,8 @@ Error compilerGlslToSpirv(CString src, ShaderType shaderType, GenericMemoryPoolA
 	glslang::TShader shader(stage);
 	Array<const char*, 1> csrc = {&src[0]};
 	shader.setStrings(&csrc[0], 1);
-	shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_2);
-	shader.setEnvTarget(glslang::EShTargetSpv, glslang::EShTargetSpv_1_5);
+	shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_1);
+	shader.setEnvTarget(glslang::EShTargetSpv, glslang::EShTargetSpv_1_3);
 	if(!shader.parse(&GLSLANG_LIMITS, 100, false, messages))
 	{
 		ANKI_CHECK(logShaderErrorCode(shader.getInfoLog(), src, tmpAlloc));