Move over to Vulkan 1.3 as default baseline

compiler/compiler.cpp

@@ -332,9 +332,9 @@ std::vector<uint32_t> GLSLCompiler::compile(std::string &error_message, const st
 	}
 
 	options.SetTargetEnvironment(shaderc_target_env_vulkan,
-	                             target == Target::Vulkan11_Spirv14 ?
-	                             shaderc_env_version_vulkan_1_2 : shaderc_env_version_vulkan_1_1);
-	options.SetTargetSpirv(target == Target::Vulkan11_Spirv14 ? shaderc_spirv_version_1_4 : shaderc_spirv_version_1_3);
+	                             target == Target::Vulkan13 ?
+	                             shaderc_env_version_vulkan_1_3 : shaderc_env_version_vulkan_1_1);
+	options.SetTargetSpirv(target == Target::Vulkan13 ? shaderc_spirv_version_1_6 : shaderc_spirv_version_1_3);
 	options.SetSourceLanguage(shaderc_source_language_glsl);
 
 	shaderc::SpvCompilationResult result;
@@ -370,7 +370,7 @@ std::vector<uint32_t> GLSLCompiler::compile(std::string &error_message, const st
 	}
 
 	std::vector<uint32_t> compiled_spirv(result.cbegin(), result.cend());
-	spvtools::SpirvTools core(target == Target::Vulkan11_Spirv14 ? SPV_ENV_VULKAN_1_1_SPIRV_1_4 : SPV_ENV_VULKAN_1_1);
+	spvtools::SpirvTools core(target == Target::Vulkan13 ? SPV_ENV_VULKAN_1_3 : SPV_ENV_VULKAN_1_1);
 	core.SetMessageConsumer([&error_message](spv_message_level_t, const char *, const spv_position_t&, const char *message) {
 		error_message = message;
 	});

compiler/compiler.hpp

@@ -48,7 +48,7 @@ enum class Stage
 enum class Target
 {
 	Vulkan11,
-	Vulkan11_Spirv14
+	Vulkan13
 };
 
 class GLSLCompiler

renderer/animation_system.cpp

@@ -486,13 +486,13 @@ void AnimationSystem::update(AnimationState *anim, double frame_time, double ela
 	{
 		auto *node = anim->skinned_node;
 		anim->animation.animate(anim->transforms_base,
-								node->get_skin()->skin.data(), node->get_skin()->skin.size(), float(offset));
+		                        node->get_skin()->skin.data(), node->get_skin()->skin.size(), float(offset));
 		node->invalidate_cached_transform();
 	}
 	else
 	{
 		anim->animation.animate(anim->transforms_base,
-								anim->channel_transforms.data(), anim->channel_transforms.size(), float(offset));
+		                        anim->channel_transforms.data(), anim->channel_transforms.size(), float(offset));
 		for (auto *node : anim->channel_nodes)
 			node->invalidate_cached_transform();
 	}
@@ -553,7 +553,7 @@ void AnimationSystem::animate(TaskComposer &composer, double frame_time, double
 }
 
 AnimationSystem::AnimationState::AnimationState(const AnimationUnrolled &anim,
-												Transform *transforms_base_,
+                                                Transform *transforms_base_,
                                                 Util::SmallVector<uint32_t> channel_transforms_,
                                                 Util::SmallVector<Node *> channel_nodes_,
                                                 double start_time_)

renderer/animation_system.hpp

@@ -105,7 +105,7 @@ class AnimationSystem
 	struct AnimationState : Util::IntrusiveUnorderedArrayEnabled
 	{
 		AnimationState(const AnimationUnrolled &anim,
-					   Transform *transforms_base_,
+		               Transform *transforms_base_,
 		               Util::SmallVector<uint32_t> channel_transforms_,
 		               Util::SmallVector<Node *> channel_nodes_,
 		               double start_time_);

renderer/fft/fft.cpp

@@ -200,7 +200,7 @@ void FFT::Impl::optimize_multi_fft(unsigned &multi_fft_x, unsigned &multi_fft_y,
 	unsigned split = split_first + split_second + split_third;
 
 	unsigned subgroup_size_log2 =
-			Util::floor_log2(std::max(1u, device->get_device_features().subgroup_properties.subgroupSize));
+			Util::floor_log2(std::max(1u, device->get_device_features().vk11_props.subgroupSize));
 	if (!subgroup_size_log2)
 		subgroup_size_log2 = 5;
 
@@ -231,7 +231,7 @@ void FFT::Impl::optimize_multi_fft(unsigned &multi_fft_x, unsigned &multi_fft_y,
 void FFT::Impl::optimize_multi_fft_resolve(unsigned &multi_fft_x, unsigned &multi_fft_y) const
 {
 	unsigned subgroup_size_log2 =
-			Util::floor_log2(std::max(1u, device->get_device_features().subgroup_properties.subgroupSize));
+			Util::floor_log2(std::max(1u, device->get_device_features().vk11_props.subgroupSize));
 	if (!subgroup_size_log2)
 		subgroup_size_log2 = 5;
 
@@ -254,8 +254,8 @@ void FFT::Impl::optimize_multi_fft_resolve(unsigned &multi_fft_x, unsigned &mult
 
 const char *FFT::Impl::get_fp16_define() const
 {
-	if (device->get_device_features().float16_int8_features.shaderFloat16 &&
-	    device->get_device_features().storage_16bit_features.storageBuffer16BitAccess)
+	if (device->get_device_features().vk12_features.shaderFloat16 &&
+	    device->get_device_features().vk11_features.storageBuffer16BitAccess)
 	{
 		return "FFT_FULL_FP16";
 	}

renderer/lights/clusterer.cpp

@@ -1661,7 +1661,7 @@ void LightClusterer::update_bindless_range_buffer_gpu(Vulkan::CommandBuffer &cmd
 	constexpr VkSubgroupFeatureFlags required =
 		VK_SUBGROUP_FEATURE_SHUFFLE_BIT |
 		VK_SUBGROUP_FEATURE_BASIC_BIT;
-	if ((features.subgroup_properties.supportedOperations & required) == required &&
+	if ((features.vk11_props.subgroupSupportedOperations & required) == required &&
 	    cmd.get_device().supports_subgroup_size_log2(true, 5, 7))
 	{
 		cmd.set_program("builtin://shaders/lights/clusterer_bindless_z_range_opt.comp");
@@ -1780,8 +1780,8 @@ void LightClusterer::update_bindless_mask_buffer_decal_gpu(Vulkan::CommandBuffer
 	constexpr VkSubgroupFeatureFlags required = VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_BASIC_BIT |
 	                                            VK_SUBGROUP_FEATURE_SHUFFLE_BIT;
 
-	if ((features.subgroup_properties.supportedOperations & required) == required &&
-	    (features.subgroup_properties.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0)
+	if ((features.vk11_props.subgroupSupportedOperations & required) == required &&
+	    (features.vk11_props.subgroupSupportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0)
 	{
 		// Our desired range is either 32 threads or 64 threads, 32 threads is preferred.
 
@@ -1881,8 +1881,8 @@ void LightClusterer::update_bindless_mask_buffer_gpu(Vulkan::CommandBuffer &cmd)
 
 	constexpr VkSubgroupFeatureFlags required = VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_BASIC_BIT;
 
-	if ((features.subgroup_properties.supportedOperations & required) == required &&
-	    (features.subgroup_properties.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0)
+	if ((features.vk11_props.subgroupSupportedOperations & required) == required &&
+	    (features.vk11_props.subgroupSupportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0)
 	{
 		// Our desired range is either 32 threads or 64 threads, 32 threads is preferred.
 

renderer/post/aa.cpp

@@ -114,7 +114,7 @@ bool setup_after_post_chain_upscaling(RenderGraph &graph, const std::string &inp
 		const char *vert = "builtin://shaders/post/ffx-fsr/upscale.vert";
 		const char *frag = "builtin://shaders/post/ffx-fsr/upscale.frag";
 
-		bool fp16 = cmd.get_device().get_device_features().float16_int8_features.shaderFloat16;
+		bool fp16 = cmd.get_device().get_device_features().vk12_features.shaderFloat16;
 		const char *fsr_fp16 = getenv("FIDELITYFX_FSR_FP16");
 		if (fsr_fp16)
 		{

renderer/post/spd.cpp

@@ -34,22 +34,22 @@ bool supports_single_pass_downsample(Vulkan::Device &device, VkFormat format)
 
 	bool supports_full_group =
 			device.supports_subgroup_size_log2(true, 2, 7);
-	bool supports_compute = (features.subgroup_properties.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0;
+	bool supports_compute = (features.vk11_props.subgroupSupportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0;
 
 	if (device.get_gpu_properties().limits.maxComputeWorkGroupSize[0] < 256)
 		return false;
 	if (!features.enabled_features.shaderStorageImageArrayDynamicIndexing)
 		return false;
 
-	VkFormatProperties3KHR props3 = { VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR };
+	VkFormatProperties3 props3 = { VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 };
 	device.get_format_properties(format, &props3);
-	if ((props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR) == 0)
+	if ((props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT) == 0)
 		return false;
-	if ((props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR) == 0)
+	if ((props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT) == 0)
 		return false;
 
 	constexpr VkSubgroupFeatureFlags required = VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT;
-	bool supports_quad_basic = (features.subgroup_properties.supportedOperations & required) == required;
+	bool supports_quad_basic = (features.vk11_props.subgroupSupportedOperations & required) == required;
 	return supports_full_group && supports_compute && supports_quad_basic;
 }
 

renderer/post/ssr.cpp

@@ -126,11 +126,11 @@ struct SSRState : RenderPassInterface
 				            VK_ACCESS_2_SHADER_SAMPLED_READ_BIT |
 				            VK_ACCESS_2_SHADER_STORAGE_READ_BIT);
 
-				VkFormatProperties3KHR props3 = { VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR };
+				VkFormatProperties3 props3 = { VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 };
 				cmd.get_device().get_format_properties(output_view->get_format(), &props3);
-				if (!(props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR))
+				if (!(props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT))
 					LOGW("Cannot read without format.\n");
-				if (!(props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR))
+				if (!(props3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT))
 					LOGW("Cannot write without format.\n");
 
 				defines.clear();

renderer/render_graph.cpp

@@ -2181,7 +2181,7 @@ void RenderGraph::physical_pass_enqueue_graphics_commands(const PhysicalPass &ph
 		}
 		else if (multiview_count)
 		{
-			if (device->get_device_features().multiview_features.multiview)
+			if (device->get_device_features().vk11_features.multiview)
 			{
 				rp_info.num_layers = physical_pass.layers;
 				rp_info.base_layer = 0;

renderer/renderer.cpp

@@ -299,11 +299,11 @@ static const char *renderer_to_define(RendererType type)
 void Renderer::add_subgroup_defines(Vulkan::Device &device, std::vector<std::pair<std::string, int>> &defines,
                                     VkShaderStageFlagBits stage)
 {
-	auto &subgroup = device.get_device_features().subgroup_properties;
+	auto &vk11 = device.get_device_features().vk11_props;
 
-	if ((subgroup.supportedStages & stage) != 0 &&
+	if ((vk11.subgroupSupportedStages & stage) != 0 &&
 	    !ImplementationQuirks::get().force_no_subgroups &&
-	    subgroup.subgroupSize >= 4)
+	    vk11.subgroupSize >= 4)
 	{
 		const VkSubgroupFeatureFlags quad_required =
 				(stage & (VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT)) != 0 ?
@@ -316,11 +316,11 @@ void Renderer::add_subgroup_defines(Vulkan::Device &device, std::vector<std::pai
 				VK_SUBGROUP_FEATURE_VOTE_BIT |
 				VK_SUBGROUP_FEATURE_ARITHMETIC_BIT;
 
-		if ((subgroup.supportedOperations & required) == required)
+		if ((vk11.subgroupSupportedOperations & required) == required)
 			defines.emplace_back("SUBGROUP_OPS", 1);
 
 		if (!ImplementationQuirks::get().force_no_subgroup_shuffle)
-			if ((subgroup.supportedOperations & VK_SUBGROUP_FEATURE_SHUFFLE_BIT) != 0)
+			if ((vk11.subgroupSupportedOperations & VK_SUBGROUP_FEATURE_SHUFFLE_BIT) != 0)
 				defines.emplace_back("SUBGROUP_SHUFFLE", 1);
 
 		if (stage == VK_SHADER_STAGE_FRAGMENT_BIT)
@@ -337,7 +337,7 @@ void Renderer::set_mesh_renderer_options_internal(RendererOptionFlags flags)
 	if (device)
 	{
 		// Safe early-discard.
-		if (device->get_device_features().demote_to_helper_invocation_features.shaderDemoteToHelperInvocation)
+		if (device->get_device_features().vk13_features.shaderDemoteToHelperInvocation)
 			global_defines.emplace_back("DEMOTE", 1);
 		add_subgroup_defines(*device, global_defines, VK_SHADER_STAGE_FRAGMENT_BIT);
 	}
@@ -872,14 +872,14 @@ void DeferredLightRenderer::render_light(Vulkan::CommandBuffer &cmd, const Rende
 	                                                              "builtin://shaders/lights/directional.frag");
 
 	auto &light = *context.get_lighting_parameters();
-	auto &subgroup = device.get_device_features().subgroup_properties;
+	auto &vk11 = device.get_device_features().vk11_props;
 
 	std::vector<std::pair<std::string, int>> defines;
 	if (light.shadows && light.shadows->get_create_info().layers > 1)
 	{
 		defines.emplace_back("SHADOW_CASCADES", 1);
-		if ((subgroup.supportedOperations & VK_SUBGROUP_FEATURE_ARITHMETIC_BIT) != 0 &&
-		    (subgroup.supportedStages & VK_SHADER_STAGE_FRAGMENT_BIT) != 0 &&
+		if ((vk11.subgroupSupportedOperations & VK_SUBGROUP_FEATURE_ARITHMETIC_BIT) != 0 &&
+		    (vk11.subgroupSupportedStages & VK_SHADER_STAGE_FRAGMENT_BIT) != 0 &&
 		    !ImplementationQuirks::get().force_no_subgroups)
 		{
 			// For cascaded shadows.

slangmosh/slangmosh.cpp

@@ -44,7 +44,7 @@ using namespace Granite;
 
 static void print_help()
 {
-	LOGE("slangmosh <desc.json> [-O] [--strip] [--spv14] [--output header.hpp] [--help] [--output-interface interface.hpp]\n");
+	LOGE("slangmosh <desc.json> [-O] [--strip] [--vk13] [--output header.hpp] [--help] [--output-interface interface.hpp]\n");
 }
 
 struct ShaderVariant
@@ -675,7 +675,7 @@ static int main_inner(int argc, char **argv)
 	cbs.add("--output", [&](CLIParser &parser) { output_path = parser.next_string(); });
 	cbs.add("-O", [&](CLIParser &) { opt = true; });
 	cbs.add("--strip", [&](CLIParser &) { strip = true; });
-	cbs.add("--spv14", [&](CLIParser &) { target = Target::Vulkan11_Spirv14; });
+	cbs.add("--vk13", [&](CLIParser &) { target = Target::Vulkan13; });
 	cbs.add("--namespace", [&](CLIParser &parser) { generated_namespace = parser.next_string(); });
 	cbs.add("--output-interface", [&](CLIParser &parser) { output_interface_path = parser.next_string(); });
 	cbs.default_handler = [&](const char *str) { input_path = str; };

tests/d3d11_interop_test.cpp

@@ -236,7 +236,7 @@ int main()
 		return EXIT_FAILURE;
 	}
 
-	auto timeline = device.request_semaphore_external(VK_SEMAPHORE_TYPE_TIMELINE_KHR,
+	auto timeline = device.request_semaphore_external(VK_SEMAPHORE_TYPE_TIMELINE,
 	                                                  VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT);
 	if (!timeline)
 	{

tests/d3d12_interop_test.cpp

@@ -253,7 +253,7 @@ int main()
 		return EXIT_FAILURE;
 	}
 
-	auto timeline = device.request_semaphore_external(VK_SEMAPHORE_TYPE_TIMELINE_KHR,
+	auto timeline = device.request_semaphore_external(VK_SEMAPHORE_TYPE_TIMELINE,
 	                                                  VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT);
 	if (!timeline)
 	{

tests/external_objects.cpp

@@ -46,7 +46,7 @@ static bool run_test(Device &producer, Device &consumer)
 	// Fallback to binary if we have to.
 
 	write_timeline = producer.request_semaphore_external(
-		VK_SEMAPHORE_TYPE_TIMELINE_KHR,
+		VK_SEMAPHORE_TYPE_TIMELINE,
 		ExternalHandle::get_opaque_semaphore_handle_type());
 
 	if (write_timeline)
@@ -56,7 +56,7 @@ static bool run_test(Device &producer, Device &consumer)
 		{
 			// No reason for this to fail if we can export timeline ...
 			read_timeline = consumer.request_semaphore_external(
-			    VK_SEMAPHORE_TYPE_TIMELINE_KHR,
+			    VK_SEMAPHORE_TYPE_TIMELINE,
 			    ExternalHandle::get_opaque_semaphore_handle_type());
 
 			if (!read_timeline)
@@ -148,7 +148,7 @@ static bool run_test(Device &producer, Device &consumer)
 		                                         VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT);
 		producer.submit(fill_cmd);
 		auto external = producer.request_semaphore_external(
-		    VK_SEMAPHORE_TYPE_BINARY_KHR, ExternalHandle::get_opaque_semaphore_handle_type());
+		    VK_SEMAPHORE_TYPE_BINARY, ExternalHandle::get_opaque_semaphore_handle_type());
 		producer.submit_empty(CommandBuffer::Type::Generic, nullptr, external.get());
 
 		ExternalHandle handle = external->export_to_handle();
@@ -157,7 +157,7 @@ static bool run_test(Device &producer, Device &consumer)
 
 		// Consume
 		auto import = consumer.request_semaphore_external(
-			VK_SEMAPHORE_TYPE_BINARY_KHR, ExternalHandle::get_opaque_semaphore_handle_type());
+			VK_SEMAPHORE_TYPE_BINARY, ExternalHandle::get_opaque_semaphore_handle_type());
 		if (!import->import_from_handle(handle))
 		{
 			close_native_handle(handle.handle);
@@ -191,15 +191,15 @@ static bool run_test(Device &producer, Device &consumer)
 			// Binary path.
 
 			external = consumer.request_semaphore_external(
-				VK_SEMAPHORE_TYPE_BINARY_KHR, ExternalHandle::get_opaque_semaphore_handle_type());
+				VK_SEMAPHORE_TYPE_BINARY, ExternalHandle::get_opaque_semaphore_handle_type());
 			consumer.submit_empty(CommandBuffer::Type::AsyncTransfer, nullptr, external.get());
 
 			handle = external->export_to_handle();
 			if (!handle)
 				break;
 
 			import = producer.request_semaphore_external(
-			    VK_SEMAPHORE_TYPE_BINARY_KHR, ExternalHandle::get_opaque_semaphore_handle_type());
+			    VK_SEMAPHORE_TYPE_BINARY, ExternalHandle::get_opaque_semaphore_handle_type());
 			if (!import->import_from_handle(handle))
 			{
 				close_native_handle(handle.handle);

tests/gl_interop_test.cpp

@@ -231,7 +231,7 @@ int main()
 		{
 			// Synchronize with OpenGL. Export a handle.
 			auto ext_semaphore = device.request_semaphore_external(
-			    VK_SEMAPHORE_TYPE_BINARY_KHR, ExternalHandle::get_opaque_semaphore_handle_type());
+			    VK_SEMAPHORE_TYPE_BINARY, ExternalHandle::get_opaque_semaphore_handle_type());
 			device.submit_empty(CommandBuffer::Type::Generic, nullptr, ext_semaphore.get());
 			auto exported_semaphore = ext_semaphore->export_to_handle();
 
@@ -255,7 +255,7 @@ int main()
 		{
 			// Synchronize with OpenGL. Export a handle that GL can signal.
 			auto ext_semaphore = device.request_semaphore_external(
-			    VK_SEMAPHORE_TYPE_BINARY_KHR, ExternalHandle::get_opaque_semaphore_handle_type());
+			    VK_SEMAPHORE_TYPE_BINARY, ExternalHandle::get_opaque_semaphore_handle_type());
 			// Have to mark the semaphore is signalled since we assert on that being the case when exporting a semaphore.
 			ext_semaphore->signal_external();
 			auto exported_semaphore = ext_semaphore->export_to_handle();

tests/triangle_mesh.cpp

@@ -47,13 +47,13 @@ struct TriangleMeshApplication : Granite::Application, Granite::EventHandler
 		auto &device = wsi.get_device();
 		auto &features = device.get_device_features();
 
-		if ((features.subgroup_properties.supportedStages & VK_SHADER_STAGE_MESH_BIT_EXT) == 0)
+		if ((features.vk11_props.subgroupSupportedStages & VK_SHADER_STAGE_MESH_BIT_EXT) == 0)
 		{
 			LOGE("Subgroups not supported in mesh.\n");
 			return;
 		}
 
-		if ((features.subgroup_properties.supportedStages & VK_SHADER_STAGE_TASK_BIT_EXT) == 0)
+		if ((features.vk11_props.subgroupSupportedStages & VK_SHADER_STAGE_TASK_BIT_EXT) == 0)
 		{
 			LOGE("Subgroups not supported in task.\n");
 			return;

tests/ycbcr_sampling.cpp

@@ -53,7 +53,7 @@ struct YCbCrSamplingTest : Granite::Application, Granite::EventHandler
 
 	void on_module_created(const DeviceShaderModuleReadyEvent &e)
 	{
-		if (!e.get_device().get_device_features().sampler_ycbcr_conversion_features.samplerYcbcrConversion)
+		if (!e.get_device().get_device_features().vk11_features.samplerYcbcrConversion)
 		{
 			LOGE("YCbCr sampling not supported!\n");
 			std::terminate();

tests/z_binning_test.cpp

@@ -35,7 +35,7 @@ static int main_inner()
 	constexpr bool UseOptimized = true;
 	bool support_optimized =
 	    UseOptimized &&
-		(features.subgroup_properties.supportedOperations & required) == required &&
+		(features.vk11_props.subgroupSupportedOperations & required) == required &&
 		device.supports_subgroup_size_log2(true, 5, 7);
 
 	auto cmd = device.request_command_buffer();