Use VKB_ENABLE_PORTABILITY vs. VK_ENABLE_BETA_EXTENSIONS to guard por…

…tability subset features

bldsys/cmake/global_options.cmake

@@ -33,15 +33,10 @@ endif()
 
 if(APPLE)
     cmake_minimum_required(VERSION 3.24)
+    set(VKB_ENABLE_PORTABILITY ON CACHE BOOL "Enable portability enumeration and subset features in the framework.  This is required to be set when running on Apple platforms." FORCE)
 if(IOS)
     set(CMAKE_XCODE_GENERATE_SCHEME TRUE)
-endif ()
-    find_package(Vulkan)
-    if(Vulkan_VERSION GREATER_EQUAL 1.3)
-        set(VKB_ENABLE_PORTABILITY ON CACHE BOOL "Enable portability extension enumeration in the framework.  This is required to be set if running MoltenVK and Vulkan 1.3+" FORCE)
-    else()
-        set(VKB_ENABLE_PORTABILITY OFF CACHE BOOL "Enable portability extension enumeration in the framework.  This is required to be off if running Vulkan less than 1.3" FORCE)
-    endif()
+endif()
 endif()
 
 set(VKB_WARNINGS_AS_ERRORS ON CACHE BOOL "Enable Warnings as Errors")

components/core/CMakeLists.txt

@@ -45,7 +45,7 @@ if(ANDROID)
 elseif(WIN32)
     target_compile_definitions(vkb__core PUBLIC VK_USE_PLATFORM_WIN32_KHR PLATFORM__WINDOWS)
 elseif(APPLE)
-    target_compile_definitions(vkb__core PUBLIC VK_USE_PLATFORM_METAL_EXT VK_ENABLE_BETA_EXTENSIONS PLATFORM__MACOS)
+    target_compile_definitions(vkb__core PUBLIC VK_USE_PLATFORM_METAL_EXT PLATFORM__MACOS)
 elseif(UNIX)
     target_compile_definitions(vkb__core PUBLIC PLATFORM__LINUX)
 

framework/CMakeLists.txt

@@ -499,7 +499,7 @@ if(${VKB_VULKAN_DEBUG})
 endif()
 
 if(${VKB_ENABLE_PORTABILITY})
-    message(STATUS "Vulkan Portability extension is enabled")
+    message(STATUS "Vulkan Portability Enumeration and Portability Subset extensions are enabled")
     target_compile_definitions(${PROJECT_NAME} PUBLIC VKB_ENABLE_PORTABILITY)
 endif()
 

framework/core/hpp_instance.cpp

@@ -327,7 +327,12 @@ HPPInstance::HPPInstance(const std::string                            &applicati
 #endif
 
 #if (defined(VKB_ENABLE_PORTABILITY))
-	instance_info.flags |= vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR;
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](vk::ExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		instance_info.flags |= vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR;
+	}
 #endif
 
 #ifdef USE_VALIDATION_LAYER_FEATURES

framework/core/instance.cpp

@@ -351,7 +351,12 @@ Instance::Instance(const std::string                            &application_nam
 #endif
 
 #if (defined(VKB_ENABLE_PORTABILITY))
-	instance_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](VkExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		instance_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	}
 #endif
 
 	// Some of the specialized layers need to be enabled explicitly

framework/vulkan_sample.h

@@ -1087,7 +1087,7 @@ inline bool VulkanSample<bindingType>::prepare(const ApplicationOptions &options
 		}
 	}
 
-#ifdef VK_ENABLE_BETA_EXTENSIONS
+#ifdef VKB_ENABLE_PORTABILITY
 	// VK_KHR_portability_subset must be enabled if present in the implementation (e.g on macOS/iOS with beta extensions enabled)
 	add_device_extension(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME, /*optional=*/true);
 #endif

samples/api/hello_triangle/hello_triangle.cpp

@@ -170,14 +170,14 @@ void HelloTriangle::init_instance(Context                         &context,
 	uint32_t instance_extension_count;
 	VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, nullptr));
 
-	std::vector<VkExtensionProperties> instance_extensions(instance_extension_count);
-	VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, instance_extensions.data()));
+	std::vector<VkExtensionProperties> available_instance_extensions(instance_extension_count);
+	VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, available_instance_extensions.data()));
 
 	std::vector<const char *> active_instance_extensions(required_instance_extensions);
 
 #if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
 	bool has_debug_report = false;
-	for (const auto &ext : instance_extensions)
+	for (const auto &ext : available_instance_extensions)
 	{
 		if (strcmp(ext.extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0)
 		{
@@ -197,7 +197,12 @@ void HelloTriangle::init_instance(Context                         &context,
 
 #if (defined(VKB_ENABLE_PORTABILITY))
 	active_instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
-	active_instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](VkExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		active_instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	}
 #endif
 
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
@@ -218,7 +223,7 @@ void HelloTriangle::init_instance(Context                         &context,
 #	pragma error Platform not supported
 #endif
 
-	if (!validate_extensions(active_instance_extensions, instance_extensions))
+	if (!validate_extensions(active_instance_extensions, available_instance_extensions))
 	{
 		throw std::runtime_error("Required instance extensions are missing.");
 	}
@@ -274,7 +279,12 @@ void HelloTriangle::init_instance(Context                         &context,
 #endif
 
 #if (defined(VKB_ENABLE_PORTABILITY))
-	instance_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](VkExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		instance_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	}
 #endif
 
 	// Create the Vulkan instance

samples/api/hpp_hello_triangle/hpp_hello_triangle.cpp

@@ -435,7 +435,12 @@ vk::Instance HPPHelloTriangle::create_instance(std::vector<const char *> const &
 
 #if (defined(VKB_ENABLE_PORTABILITY))
 	active_instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
-	active_instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](vk::ExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		active_instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	}
 #endif
 
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
@@ -499,7 +504,12 @@ vk::Instance HPPHelloTriangle::create_instance(std::vector<const char *> const &
 #endif
 
 #if (defined(VKB_ENABLE_PORTABILITY))
-	instance_info.flags |= vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR;
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](vk::ExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		instance_info.flags |= vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR;
+	}
 #endif
 
 	// Create the Vulkan instance

samples/extensions/portability/portability.cpp

@@ -36,7 +36,7 @@ Portability::Portability() :
 	// Portability is a Vulkan 1.3 extension
 	set_api_version(VK_API_VERSION_1_3);
 	add_instance_extension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
-	add_instance_extension(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	add_instance_extension(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME, /*optional*/ true);
 }
 
 Portability::~Portability()
@@ -832,7 +832,7 @@ bool Portability::prepare(const vkb::ApplicationOptions &options)
 	// Note: Using reversed depth-buffer for increased precision, so Znear and Zfar are flipped
 	camera.set_perspective(60.0f, static_cast<float>(width) / static_cast<float>(height), 256.0f, 0.1f);
 
-#ifdef VK_ENABLE_BETA_EXTENSIONS
+#ifdef VKB_ENABLE_PORTABILITY
 	portability_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
 	VkPhysicalDeviceFeatures2 device_features{};
 	device_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
@@ -867,7 +867,7 @@ void Portability::render(float delta_time)
 
 void Portability::on_update_ui_overlay(vkb::Drawer &drawer)
 {
-#ifdef VK_ENABLE_BETA_EXTENSIONS
+#ifdef VKB_ENABLE_PORTABILITY
 	std::string portability_support_list;
 	if (portability_features.constantAlphaColorBlendFactors)
 		portability_support_list += "constantAlphaColorBlendFactors\n";
@@ -901,7 +901,7 @@ void Portability::on_update_ui_overlay(vkb::Drawer &drawer)
 		portability_support_list += "vertexAttributeAccessBeyondStride\n";
 	drawer.text("Device Portability feature support list:\n%s", portability_support_list.c_str());
 #else
-	drawer.text("VK_ENABLE_BETA_EXTENSIONS not enabled can't list portability feature set");
+	drawer.text("VKB_ENABLE_PORTABILITY not enabled can't list portability feature set");
 #endif
 	if (drawer.header("Settings"))
 	{

samples/extensions/portability/portability.h

@@ -28,7 +28,7 @@ class Portability : public ApiVulkanSample
   public:
 	bool bloom             = true;
 	bool display_skysphere = true;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
+#ifdef VKB_ENABLE_PORTABILITY
 	VkPhysicalDevicePortabilitySubsetFeaturesKHR portability_features{};
 #endif
 

samples/extensions/shader_debugprintf/shader_debugprintf.cpp

@@ -439,14 +439,16 @@ std::unique_ptr<vkb::Instance> ShaderDebugPrintf::create_instance(bool headless)
 	VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, available_instance_extensions.data()));
 
 	// When VK_EXT_layer_settings is available at runtime, the debugPrintfEXT layer feature is enabled using the standard framework
-	// Note this check is necessary in the short term for backwards compatibility with SDKs < 1.3.272 without VK_EXT_layer_settings
+	// For backwards compatibility with SDKs < 1.3.272 without VK_EXT_layer_settings, the remainder of this custom override is required
 	if (std::any_of(available_instance_extensions.begin(),
 	                available_instance_extensions.end(),
 	                [](VkExtensionProperties extension) { return strcmp(extension.extensionName, VK_EXT_LAYER_SETTINGS_EXTENSION_NAME) == 0; }))
 	{
+		// Run standard create_instance() from framework (with layer settings support) and return
 		return VulkanSample::create_instance(headless);
 	}
 
+	// Run remainder of this custom create_instance() (without layer settings support) and return
 	std::vector<const char *> enabled_extensions;
 	enabled_extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
 
@@ -458,7 +460,12 @@ std::unique_ptr<vkb::Instance> ShaderDebugPrintf::create_instance(bool headless)
 	enabled_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
 	enabled_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
 #if (defined(VKB_ENABLE_PORTABILITY))
-	enabled_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](VkExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		enabled_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+	}
 #endif
 
 	VkApplicationInfo app_info{VK_STRUCTURE_TYPE_APPLICATION_INFO};
@@ -482,7 +489,12 @@ std::unique_ptr<vkb::Instance> ShaderDebugPrintf::create_instance(bool headless)
 	instance_create_info.ppEnabledLayerNames     = validation_layers.data();
 	instance_create_info.enabledLayerCount       = static_cast<uint32_t>(validation_layers.size());
 #if (defined(VKB_ENABLE_PORTABILITY))
-	instance_create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	if (std::any_of(available_instance_extensions.begin(),
+	                available_instance_extensions.end(),
+	                [](VkExtensionProperties extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
+	{
+		instance_create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	}
 #endif
 	instance_create_info.pNext = &validation_features;
 

samples/performance/async_compute/async_compute.cpp

@@ -40,8 +40,8 @@ AsyncComputeSample::AsyncComputeSample()
 
 void AsyncComputeSample::request_gpu_features(vkb::PhysicalDevice &gpu)
 {
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-	// We need to enable the mutableComparisonSamplers feature of the VK_KHR_portability_subset extension
+#ifdef VKB_ENABLE_PORTABILITY
+	// Since sampler_info.compareEnable = VK_TRUE, must enable the mutableComparisonSamplers feature of VK_KHR_portability_subset
 	auto &requested_portability_subset_features                     = gpu.request_extension_features<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR);
 	requested_portability_subset_features.mutableComparisonSamplers = VK_TRUE;
 #endif

samples/performance/multithreading_render_passes/multithreading_render_passes.cpp

@@ -41,8 +41,8 @@ MultithreadingRenderPasses::MultithreadingRenderPasses()
 
 void MultithreadingRenderPasses::request_gpu_features(vkb::PhysicalDevice &gpu)
 {
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-	// We need to enable the mutableComparisonSamplers feature of the VK_KHR_portability_subset extension
+#ifdef VKB_ENABLE_PORTABILITY
+	// Since shadowmap_sampler_create_info.compareEnable = VK_TRUE, must enable the mutableComparisonSamplers feature of VK_KHR_portability_subset
 	auto &requested_portability_subset_features                     = gpu.request_extension_features<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR);
 	requested_portability_subset_features.mutableComparisonSamplers = VK_TRUE;
 #endif

third_party/CMakeLists.txt

@@ -49,13 +49,17 @@ target_include_directories(vulkan SYSTEM INTERFACE ${VULKAN_INCLUDE_DIR})
 
 target_compile_definitions(vulkan INTERFACE VK_NO_PROTOTYPES)
 
+if(VKB_ENABLE_PORTABILITY)
+	# When portability is enabled, must enable Vulkan beta extensions for access to VK_KHR_portability_subset
+    target_compile_definitions(vulkan INTERFACE VK_ENABLE_BETA_EXTENSIONS)
+endif()
 
 if(ANDROID)
     target_compile_definitions(vulkan INTERFACE VK_USE_PLATFORM_ANDROID_KHR)
 elseif(WIN32)
     target_compile_definitions(vulkan INTERFACE VK_USE_PLATFORM_WIN32_KHR)
 elseif(APPLE)
-	target_compile_definitions(vulkan INTERFACE VK_USE_PLATFORM_METAL_EXT VK_ENABLE_BETA_EXTENSIONS)
+	target_compile_definitions(vulkan INTERFACE VK_USE_PLATFORM_METAL_EXT)
 elseif(UNIX)
     # Choose WSI based on VKB_WSI_SELECTION
     if (VKB_WSI_SELECTION STREQUAL XCB OR VKB_WSI_SELECTION STREQUAL XLIB OR VKB_WSI_SELECTION STREQUAL WAYLAND)