Merge branch 'main' into shader_quad_control

Author: gpx1000

.github/workflows/build.yml

@@ -56,7 +56,7 @@ jobs:
           cmake --build "build/${{ matrix.platform }}" --target vulkan_samples --config ${{ matrix.build_type }} ${{ env.PARALLEL }}
 
   build_v2:
-    name: "Build ${{ matrix.platform }} in ${{ matrix.build_type }}"
+    name: "Build v2 Components ${{ matrix.platform }} in ${{ matrix.build_type }}"
     strategy:
       matrix:
         platform: [windows, ubuntu]

antora/modules/ROOT/nav.adoc

@@ -1,6 +1,6 @@
 ////
-- Copyright (c) 2023-2025, Holochip Inc
-- Copyright (c) 2023-2025, Sascha Willems
+- Copyright (c) 2023-2026, Holochip Inc
+- Copyright (c) 2023-2026, Sascha Willems
 - Copyright (c) 2025, Arm Limited and Contributors
 -
 - SPDX-License-Identifier: Apache-2.0
@@ -84,6 +84,7 @@
 *** xref:samples/extensions/hpp_push_descriptors/README.adoc[Push descriptors (Vulkan-Hpp)]
 ** xref:samples/extensions/ray_tracing_basic/README.adoc[Raytracing basic]
 ** xref:samples/extensions/ray_tracing_extended/README.adoc[Raytracing extended]
+** xref:samples/extensions/ray_tracing_invocation_reorder/README.adoc[Ray tracing invocation reorder (SER)]
 ** xref:samples/extensions/ray_queries/README.adoc[Ray queries]
 ** xref:samples/extensions/ray_tracing_reflection/README.adoc[Ray tracing reflection]
 ** xref:samples/extensions/ray_tracing_position_fetch/README.adoc[Ray tracing position fetch]

app/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2024, Arm Limited and Contributors
+# Copyright (c) 2019-2025, Arm Limited and Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
 #
@@ -135,7 +135,7 @@ if(IOS)
                 XCODE_EMBED_FRAMEWORKS_CODE_SIGN_ON_COPY		"YES"
         )
     endif ()
-    # No need to search for Vulkan package or MoltenVK library, Vulkan cache variables already defined on Apple platforms by global_options.cmake
+    # Vulkan cache variables already defined by main project CMakeLists and updated on Apple platforms by global_options.cmake
     if(Vulkan_LIBRARY AND ${Vulkan_VERSION} VERSION_GREATER_EQUAL 1.3.278)
         target_sources(${PROJECT_NAME} PRIVATE
                 ${Vulkan_Target_SDK}/iOS/share/vulkan
@@ -163,17 +163,24 @@ if(IOS)
     set(FRAMEWORKS_TO_EMBED)
 	if(Vulkan_MoltenVK_LIBRARY)
 		list(APPEND FRAMEWORKS_TO_EMBED "${Vulkan_MoltenVK_LIBRARY};")
+		message(STATUS "Embedding Vulkan driver: ${Vulkan_MoltenVK_LIBRARY}")
+	# add support for potentially other iOS Vulkan drivers here...
+	#elseif(OTHER_IOS_VULKAN_DRIVER)
+		#list(APPEND FRAMEWORKS_TO_EMBED "${OTHER_IOS_VULKAN_DRIVER};")
+		#message(STATUS "Embedding Vulkan driver: ${OTHER_IOS_VULKAN_DRIVER}")
 	else()
-		message(FATAL_ERROR "Can't find MoltenVK library. Please install the Vulkan SDK or MoltenVK project and set VULKAN_SDK.")
+		message(FATAL_ERROR "Can't find Vulkan driver for iOS. Please install the Vulkan SDK and run: 'source <MY_SDK_PATH>/iOS/setup-env.sh'")
 	endif()
 	if(Vulkan_LIBRARY)
 		list(APPEND FRAMEWORKS_TO_EMBED "${Vulkan_LIBRARY};")
+		message(STATUS "Embedding Vulkan loader: ${Vulkan_LIBRARY}")
 	endif()
 	if(Vulkan_Layer_VALIDATION)
 		# trouble is can't turn this on/off if XCode decides to build debug and we're configured for release.  Need to revist
 		# note the Vulkan validation layer must be present and enabled even in release mode for the shader_debugprintf sample
 		#if(("${VKB_DEBUG}" STREQUAL "ON") OR ("${VKB_VALIDATION_LAYERS}" STREQUAL "ON"))
 			list(APPEND FRAMEWORKS_TO_EMBED "${Vulkan_Layer_VALIDATION}")
+			message(STATUS "Embedding Vulkan Validation Layer: ${Vulkan_Layer_VALIDATION}")
 		#endif()
     endif()
     set_target_properties(${PROJECT_NAME} PROPERTIES

bldsys/cmake/global_options.cmake

@@ -33,11 +33,13 @@ 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)
+    option(VKB_ENABLE_PORTABILITY "Enable portability enumeration and subset features in the framework. This is default ON for Apple platforms." ON)
 
+	# the following assumes MoltenVK is used for these cases: a) standalone deployment on macOS (i.e. set USE_MoltenVK=ON), and b) for iOS deployment
+	# if this assumption changes (e.g. KosmicKrisp adds standalone or iOS support), then this section will require modification to handle optionality
 	find_package(Vulkan QUIET OPTIONAL_COMPONENTS MoltenVK)
 	if(USE_MoltenVK OR (IOS AND (NOT Vulkan_MoltenVK_FOUND OR ${CMAKE_OSX_SYSROOT} STREQUAL "iphonesimulator")))
-		# if using MoltenVK, or MoltenVK for iOS was not found, or using iOS Simulator, look for MoltenVK in the Vulkan SDK and MoltenVK project locations
+		# if using MoltenVK standalone, or MoltenVK for iOS not found or using iOS Simulator, look for MoltenVK in Vulkan SDK and MoltenVK project paths
 		if(NOT Vulkan_MoltenVK_LIBRARY)
 			# since both are available in the Vulkan SDK and MoltenVK github project, make sure we look for MoltenVK framework on iOS and dylib on macOS
 			set(_saved_cmake_find_framework ${CMAKE_FIND_FRAMEWORK})
@@ -58,7 +60,8 @@ if(APPLE)
 			# on iOS we can control Vulkan library loading priority by selecting which libraries are embedded in the iOS application bundle
 			if(IOS)
 				add_compile_definitions(_HPP_VULKAN_LIBRARY="MoltenVK.framework/MoltenVK")
-				# unset FindVulkan.cmake cache variables so Vulkan loader, Validation Layer, and icd/layer json files are not embedded on iOS
+				# unset FindVulkan.cmake cache variables so Vulkan loader and Validation Layer libraries are not embedded on iOS Simulator
+				# the iOS Simulator supports arm64 & x86_64 hosts, but the Vulkan loader and Validation Layer are compiled for arm64 only
 				unset(Vulkan_LIBRARY CACHE)
 				unset(Vulkan_Layer_VALIDATION CACHE)
 
@@ -69,15 +72,18 @@ if(APPLE)
 				add_compile_definitions(_GLFW_VULKAN_LIBRARY="libMoltenVK.dylib")
 				set(ENV{DYLD_LIBRARY_PATH} "${MoltenVK_LIBRARY_PATH}:$ENV{DYLD_LIBRARY_PATH}")
 			else()
-				message(FATAL_ERROR "Vulkan library found in MoltenVK search path. Please set VULKAN_SDK to the MoltenVK project install location.")
+				message(FATAL_ERROR "Vulkan loader found in MoltenVK search path. Please set VULKAN_SDK to the MoltenVK project install location.")
 			endif()
-			message(STATUS "Using MoltenVK: ${Vulkan_MoltenVK_LIBRARY}")
+			message(STATUS "Using MoltenVK standalone: ${Vulkan_MoltenVK_LIBRARY}")
 		else()
 			message(FATAL_ERROR "Can't find MoltenVK library. Please install the Vulkan SDK or MoltenVK project and set VULKAN_SDK.")
 		endif()
-	elseif(IOS)
-		# if not using MoltenVK on iOS, set up global Vulkan Library define for iOS Vulkan loader
-		add_compile_definitions(_HPP_VULKAN_LIBRARY="vulkan.framework/vulkan")
+	#elseif(OTHER_VULKAN_DRIVER)
+		# handle any special processing here for other Vulkan driver (e.g. KosmicKrisp) for standalone usage on macOS or deployment to iOS
+		# would likely require extensions to CMake find_package() OPTIONAL_COMPONENTS and library variables to identify & use other driver
+	#else()
+		# if not using standalone driver, retain find_package() results for Vulkan driver, Vulkan loader, and Validation Layer library variables
+		# no need to override with _HPP_VULKAN_LIBRARY in this case since Vulkan DynamicLoader will find/load Vulkan library on macOS & iOS
 	endif()
 
 	if(CMAKE_GENERATOR MATCHES "Xcode")
@@ -103,6 +109,8 @@ if(APPLE)
 			set(CMAKE_SUPPRESS_REGENERATION ON)
 		endif()
 	endif()
+else()
+    option(VKB_ENABLE_PORTABILITY "Enable portability enumeration and subset features in the framework. This is default OFF for non-Apple platforms." OFF)
 endif()
 
 set(VKB_WARNINGS_AS_ERRORS ON CACHE BOOL "Enable Warnings as Errors")

framework/CMakeLists.txt

@@ -130,8 +130,7 @@ set(RENDERING_SUBPASSES_FILES
     rendering/subpasses/hpp_forward_subpass.h
     # Source files
     rendering/subpasses/forward_subpass.cpp
-    rendering/subpasses/lighting_subpass.cpp
-    rendering/subpasses/geometry_subpass.cpp)
+    rendering/subpasses/lighting_subpass.cpp)
 
 set(SCENE_GRAPH_FILES
     # Header Files

framework/core/hpp_descriptor_set_layout.h

@@ -64,6 +64,12 @@ class HPPDescriptorSetLayout : private vkb::DescriptorSetLayout
 		    reinterpret_cast<vk::DescriptorSetLayoutBinding *>(vkb::DescriptorSetLayout::get_layout_binding(binding_index).release()));
 	}
 
+	std::unique_ptr<vk::DescriptorSetLayoutBinding> get_layout_binding(std::string const &name) const
+	{
+		return std::unique_ptr<vk::DescriptorSetLayoutBinding>(
+		    reinterpret_cast<vk::DescriptorSetLayoutBinding *>(vkb::DescriptorSetLayout::get_layout_binding(name).release()));
+	}
+
 	vk::DescriptorBindingFlagsEXT get_layout_binding_flag(const uint32_t binding_index) const
 	{
 		return static_cast<vk::DescriptorBindingFlagsEXT>(vkb::DescriptorSetLayout::get_layout_binding_flag(binding_index));

framework/core/hpp_shader_module.h

@@ -84,6 +84,7 @@ struct HPPShaderResource
 class HPPShaderSource : private vkb::ShaderSource
 {
   public:
+	HPPShaderSource() = default;
 	HPPShaderSource(const std::string &filename) :
 	    vkb::ShaderSource(filename)
 	{}
@@ -96,6 +97,7 @@ class HPPShaderModule : private vkb::ShaderModule
 {
   public:
 	using vkb::ShaderModule::get_id;
+	using vkb::ShaderModule::set_resource_mode;
 
   public:
 	HPPShaderModule(vkb::core::DeviceCpp              &device,

framework/core/instance.h

@@ -251,9 +251,19 @@ inline bool enable_layer_setting(vk::LayerSettingEXT const        &requested_lay
 	// Vulkan does not provide a reflection API for layer settings. Layer settings are described in each layer JSON manifest.
 	bool is_available = std::ranges::any_of(
 	    enabled_layers, [&requested_layer_setting](auto const &available_layer) { return strcmp(available_layer, requested_layer_setting.pLayerName) == 0; });
+
 #if defined(PLATFORM__MACOS)
-	// On Apple platforms the MoltenVK layer is implicitly enabled and available, and cannot be explicitly added or checked via enabled_layers.
-	is_available = is_available || strcmp(requested_layer_setting.pLayerName, "MoltenVK") == 0;
+	// On Apple the MoltenVK driver configuration layer is implicitly enabled and available, and cannot be explicitly added or checked via enabled_layers.
+	if (!is_available && strcmp(requested_layer_setting.pLayerName, "MoltenVK") == 0)
+	{
+		// Check for VK_EXT_layer_settings extension in the driver which indicates MoltenVK vs. KosmicKrisp (note: VK_MVK_moltenvk extension is deprecated).
+		std::vector<vk::ExtensionProperties> available_instance_extensions = vk::enumerateInstanceExtensionProperties();
+		if (std::ranges::any_of(available_instance_extensions,
+		                        [](vk::ExtensionProperties const &extension) { return strcmp(extension.extensionName, VK_EXT_LAYER_SETTINGS_EXTENSION_NAME) == 0; }))
+		{
+			is_available = true;
+		}
+	}
 #endif
 
 	if (!is_available)

framework/rendering/subpass.h

@@ -30,7 +30,6 @@
 namespace vkb
 {
 class RenderTarget;
-class ShaderSource;
 
 namespace core
 {
@@ -83,12 +82,12 @@ class Subpass
 	using ResolveModeFlagBitsType = typename std::conditional<bindingType == vkb::BindingType::Cpp, vk::ResolveModeFlagBits, VkResolveModeFlagBits>::type;
 	using SampleCountflagBitsType = typename std::conditional<bindingType == vkb::BindingType::Cpp, vk::SampleCountFlagBits, VkSampleCountFlagBits>::type;
 
-	using DepthStencilStateType =
-	    typename std::conditional<bindingType == vkb::BindingType::Cpp, vkb::rendering::HPPDepthStencilState, vkb::DepthStencilState>::type;
-	using RenderTargetType = typename std::conditional<bindingType == vkb::BindingType::Cpp, vkb::rendering::HPPRenderTarget, vkb::RenderTarget>::type;
+	using DepthStencilStateType = typename std::conditional<bindingType == vkb::BindingType::Cpp, vkb::rendering::HPPDepthStencilState, vkb::DepthStencilState>::type;
+	using RenderTargetType      = typename std::conditional<bindingType == vkb::BindingType::Cpp, vkb::rendering::HPPRenderTarget, vkb::RenderTarget>::type;
+	using ShaderSourceType      = typename std::conditional<bindingType == BindingType::Cpp, vkb::core::HPPShaderSource, vkb::ShaderSource>::type;
 
   public:
-	Subpass(vkb::rendering::RenderContext<bindingType> &render_context, ShaderSource &&vertex_shader, ShaderSource &&fragment_shader);
+	Subpass(vkb::rendering::RenderContext<bindingType> &render_context, ShaderSourceType &&vertex_shader, ShaderSourceType &&fragment_shader);
 
 	Subpass(const Subpass &)            = delete;
 	Subpass(Subpass &&)                 = default;
@@ -124,14 +123,14 @@ class Subpass
 	ResolveModeFlagBitsType                                    get_depth_stencil_resolve_mode() const;
 	DepthStencilStateType                                     &get_depth_stencil_state();
 	const bool                                                &get_disable_depth_stencil_attachment() const;
-	const ShaderSource                                        &get_fragment_shader() const;
+	const ShaderSourceType                                    &get_fragment_shader() const;
 	const std::vector<uint32_t>                               &get_input_attachments() const;
 	LightingState<bindingType>                                &get_lighting_state();
 	const std::vector<uint32_t>                               &get_output_attachments() const;
 	RenderContext<bindingType>                                &get_render_context();
 	std::unordered_map<std::string, ShaderResourceMode> const &get_resource_mode_map() const;
 	SampleCountflagBitsType                                    get_sample_count() const;
-	const ShaderSource                                        &get_vertex_shader() const;
+	const ShaderSourceType                                    &get_vertex_shader() const;
 	void                                                       set_color_resolve_attachments(std::vector<uint32_t> const &color_resolve);
 	void                                                       set_debug_name(const std::string &name);
 	void                                                       set_disable_depth_stencil_attachment(bool disable_depth_stencil);
@@ -148,6 +147,14 @@ class Subpass
 	 */
 	void update_render_target_attachments(RenderTargetType &render_target);
 
+  protected:
+	vkb::rendering::HPPDepthStencilState get_depth_stencil_state_impl() const;
+	vkb::core::HPPShaderSource const    &get_fragment_shader_impl() const;
+	LightingStateCpp                    &get_lighting_state_impl();
+	vk::SampleCountFlagBits              get_sample_count_impl() const;
+	vkb::rendering::RenderContextCpp    &get_render_context_impl();
+	vkb::core::HPPShaderSource const    &get_vertex_shader_impl() const;
+
   private:
 	/// Default to no color resolve attachments
 	std::vector<uint32_t> color_resolve_attachments = {};
@@ -175,7 +182,7 @@ class Subpass
 	/// The structure containing all the requested render-ready lights for the scene
 	LightingStateCpp lighting_state{};
 
-	ShaderSource fragment_shader;
+	vkb::core::HPPShaderSource fragment_shader;
 
 	/// Default to no input attachments
 	std::vector<uint32_t> input_attachments = {};
@@ -188,8 +195,8 @@ class Subpass
 	// A map of shader resource names and the mode of constant data
 	std::unordered_map<std::string, ShaderResourceMode> resource_mode_map;
 
-	vk::SampleCountFlagBits sample_count{vk::SampleCountFlagBits::e1};
-	ShaderSource            vertex_shader;
+	vk::SampleCountFlagBits    sample_count{vk::SampleCountFlagBits::e1};
+	vkb::core::HPPShaderSource vertex_shader;
 };
 
 using SubpassC   = Subpass<vkb::BindingType::C>;
@@ -206,12 +213,20 @@ inline glm::mat4 vulkan_style_projection(const glm::mat4 &proj)
 
 template <vkb::BindingType bindingType>
 inline Subpass<bindingType>::Subpass(vkb::rendering::RenderContext<bindingType> &render_context,
-                                     ShaderSource                              &&vertex_source,
-                                     ShaderSource                              &&fragment_source) :
-    render_context{reinterpret_cast<vkb::rendering::RenderContextCpp &>(render_context)},
-    vertex_shader{std::move(vertex_source)},
-    fragment_shader{std::move(fragment_source)}
+                                     ShaderSourceType                          &&vertex_source,
+                                     ShaderSourceType                          &&fragment_source) :
+    render_context{reinterpret_cast<vkb::rendering::RenderContextCpp &>(render_context)}
 {
+	if constexpr (bindingType == vkb::BindingType::Cpp)
+	{
+		vertex_shader   = std::move(vertex_source);
+		fragment_shader = std::move(fragment_source);
+	}
+	else
+	{
+		vertex_shader   = std::move(reinterpret_cast<vkb::core::HPPShaderSource &&>(vertex_source));
+		fragment_shader = std::move(reinterpret_cast<vkb::core::HPPShaderSource &&>(fragment_source));
+	}
 }
 
 template <vkb::BindingType bindingType>
@@ -263,18 +278,25 @@ inline typename Subpass<bindingType>::SampleCountflagBitsType Subpass<bindingTyp
 {
 	if constexpr (bindingType == vkb::BindingType::Cpp)
 	{
-		return sample_count;
+		return get_sample_count_impl();
 	}
 	else
 	{
-		return static_cast<VkSampleCountFlagBits>(sample_count);
+		return static_cast<VkSampleCountFlagBits>(get_sample_count_impl());
 	}
 }
 
 template <vkb::BindingType bindingType>
-inline const ShaderSource &Subpass<bindingType>::get_vertex_shader() const
+inline const typename Subpass<bindingType>::ShaderSourceType &Subpass<bindingType>::get_vertex_shader() const
 {
-	return vertex_shader;
+	if constexpr (bindingType == vkb::BindingType::Cpp)
+	{
+		return get_vertex_shader_impl();
+	}
+	else
+	{
+		return reinterpret_cast<vkb::ShaderSource const &>(get_vertex_shader_impl());
+	}
 }
 
 template <vkb::BindingType bindingType>
@@ -402,9 +424,16 @@ inline const bool &Subpass<bindingType>::get_disable_depth_stencil_attachment()
 }
 
 template <vkb::BindingType bindingType>
-inline const ShaderSource &Subpass<bindingType>::get_fragment_shader() const
+inline const typename Subpass<bindingType>::ShaderSourceType &Subpass<bindingType>::get_fragment_shader() const
 {
-	return fragment_shader;
+	if constexpr (bindingType == vkb::BindingType::Cpp)
+	{
+		return get_fragment_shader_impl();
+	}
+	else
+	{
+		return reinterpret_cast<vkb::ShaderSource const &>(get_fragment_shader_impl());
+	}
 }
 
 template <vkb::BindingType bindingType>
@@ -475,5 +504,42 @@ inline void Subpass<bindingType>::update_render_target_attachments(RenderTargetT
 	render_target.set_input_attachments(input_attachments);
 	render_target.set_output_attachments(output_attachments);
 }
+
+template <vkb::BindingType bindingType>
+inline vkb::core::HPPShaderSource const &Subpass<bindingType>::get_fragment_shader_impl() const
+{
+	return fragment_shader;
+}
+
+template <vkb::BindingType bindingType>
+inline vk::SampleCountFlagBits Subpass<bindingType>::get_sample_count_impl() const
+{
+	return sample_count;
+}
+
+template <vkb::BindingType bindingType>
+inline vkb::rendering::HPPDepthStencilState Subpass<bindingType>::get_depth_stencil_state_impl() const
+{
+	return depth_stencil_state;
+}
+
+template <vkb::BindingType bindingType>
+inline LightingStateCpp &Subpass<bindingType>::get_lighting_state_impl()
+{
+	return lighting_state;
+}
+
+template <vkb::BindingType bindingType>
+inline vkb::rendering::RenderContextCpp &Subpass<bindingType>::get_render_context_impl()
+{
+	return render_context;
+}
+
+template <vkb::BindingType bindingType>
+inline vkb::core::HPPShaderSource const &Subpass<bindingType>::get_vertex_shader_impl() const
+{
+	return vertex_shader;
+}
+
 }        // namespace rendering
 }        // namespace vkb

framework/rendering/subpasses/forward_subpass.cpp

@@ -43,7 +43,7 @@ ForwardSubpass::ForwardSubpass(
 void ForwardSubpass::prepare()
 {
 	auto &device = get_render_context().get_device();
-	for (auto &mesh : meshes)
+	for (auto &mesh : get_meshes())
 	{
 		for (auto &sub_mesh : mesh->get_submeshes())
 		{
@@ -56,7 +56,7 @@ void ForwardSubpass::prepare()
 
 void ForwardSubpass::draw(vkb::core::CommandBufferC &command_buffer)
 {
-	allocate_lights<ForwardLights>(scene.get_components<sg::Light>(), MAX_FORWARD_LIGHT_COUNT);
+	allocate_lights<ForwardLights>(get_scene().get_components<sg::Light>(), MAX_FORWARD_LIGHT_COUNT);
 	command_buffer.bind_lighting(get_lighting_state(), 0, 4);
 
 	GeometrySubpass::draw(command_buffer);