Transcoded version of performance sample texture_compression_comparison based on Vulkan-Hpp (#1102)

Author: asuessenbach

antora/modules/ROOT/nav.adoc

@@ -111,6 +111,7 @@
 *** xref:samples/performance/hpp_swapchain_images/README.adoc[Swapchain images (Vulkan-Hpp)]
 ** xref:samples/performance/texture_compression_basisu/README.adoc[Texture compression basisu]
 ** xref:samples/performance/texture_compression_comparison/README.adoc[Texture compression comparison]
+*** xref:samples/performance/hpp_texture_compression_comparison/README.adoc[Texture compression comparison (Vulkan-Hpp)]
 ** xref:samples/performance/wait_idle/README.adoc[Wait idle]
 * xref:samples/tooling/README.adoc[Tooling samples]
 ** xref:samples/tooling/profiles/README.adoc[Profiles]

framework/CMakeLists.txt

@@ -148,6 +148,7 @@ set(SCENE_GRAPH_FILES
     scene_graph/node.h
     scene_graph/scene.h
     scene_graph/script.h
+    scene_graph/hpp_scene.h
     # Source Files
     scene_graph/component.cpp
     scene_graph/node.cpp
@@ -173,7 +174,10 @@ set(SCENE_GRAPH_COMPONENT_FILES
     scene_graph/components/image/ktx.h
     scene_graph/components/image/stb.h
     scene_graph/components/hpp_image.h
+    scene_graph/components/hpp_material.h
+    scene_graph/components/hpp_mesh.h
     scene_graph/components/hpp_sub_mesh.h
+    scene_graph/components/hpp_texture.h
     # Source Files
     scene_graph/components/aabb.cpp
     scene_graph/components/camera.cpp

framework/common/hpp_utils.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2021-2023, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2021-2024, NVIDIA CORPORATION. All rights reserved.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -20,6 +20,7 @@
 #include <common/utils.h>
 
 #include <rendering/hpp_render_context.h>
+#include <scene_graph/hpp_scene.h>
 
 /**
  * @brief facade helper functions around the functions in common/utils.h, providing a vulkan.hpp-based interface
@@ -28,9 +29,9 @@ namespace vkb
 {
 namespace common
 {
-inline sg::Node &add_free_camera(sg::Scene &scene, const std::string &node_name, vk::Extent2D const &extent)
+inline sg::Node &add_free_camera(vkb::scene_graph::HPPScene &scene, const std::string &node_name, vk::Extent2D const &extent)
 {
-	return vkb::add_free_camera(scene, node_name, static_cast<VkExtent2D>(extent));
+	return vkb::add_free_camera(reinterpret_cast<vkb::sg::Scene &>(scene), node_name, static_cast<VkExtent2D>(extent));
 }
 
 inline void screenshot(vkb::rendering::HPPRenderContext &render_context, const std::string &filename)

framework/hpp_gltf_loader.h

@@ -21,6 +21,7 @@
 
 #include <core/hpp_device.h>
 #include <scene_graph/components/hpp_sub_mesh.h>
+#include <scene_graph/hpp_scene.h>
 
 namespace vkb
 {
@@ -32,8 +33,6 @@ namespace vkb
 class HPPGLTFLoader : private vkb::GLTFLoader
 {
   public:
-	using vkb::GLTFLoader::read_scene_from_file;
-
 	HPPGLTFLoader(vkb::core::HPPDevice &device) :
 	    GLTFLoader(reinterpret_cast<vkb::Device &>(device))
 	{}
@@ -44,5 +43,10 @@ class HPPGLTFLoader : private vkb::GLTFLoader
 		return std::unique_ptr<vkb::scene_graph::components::HPPSubMesh>(reinterpret_cast<vkb::scene_graph::components::HPPSubMesh *>(
 		    vkb::GLTFLoader::read_model_from_file(file_name, index, storage_buffer, static_cast<VkBufferUsageFlags>(additional_buffer_usage_flags)).release()));
 	}
+
+	std::unique_ptr<vkb::scene_graph::HPPScene> read_scene_from_file(const std::string &file_name, int scene_index = -1)
+	{
+		return std::unique_ptr<vkb::scene_graph::HPPScene>(reinterpret_cast<vkb::scene_graph::HPPScene *>(vkb::GLTFLoader::read_scene_from_file(file_name, scene_index).release()));
+	}
 };
 }        // namespace vkb

framework/rendering/subpasses/hpp_forward_subpass.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -36,14 +36,14 @@ class HPPForwardSubpass : public vkb::ForwardSubpass
 {
   public:
 	HPPForwardSubpass(vkb::rendering::HPPRenderContext &render_context,
-	                  vkb::ShaderSource &&              vertex_shader,
-	                  vkb::ShaderSource &&              fragment_shader,
-	                  vkb::sg::Scene &                  scene,
-	                  vkb::sg::Camera &                 camera) :
+	                  vkb::ShaderSource               &&vertex_shader,
+	                  vkb::ShaderSource               &&fragment_shader,
+	                  vkb::scene_graph::HPPScene       &scene,
+	                  vkb::sg::Camera                  &camera) :
 	    vkb::ForwardSubpass(reinterpret_cast<vkb::RenderContext &>(render_context),
 	                        std::forward<ShaderSource>(vertex_shader),
 	                        std::forward<ShaderSource>(fragment_shader),
-	                        scene,
+	                        reinterpret_cast<vkb::sg::Scene &>(scene),
 	                        camera)
 	{}
 };

framework/scene_graph/components/hpp_material.h

@@ -0,0 +1,44 @@
+/* Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "hpp_texture.h"
+#include "material.h"
+
+namespace vkb
+{
+namespace scene_graph
+{
+namespace components
+{
+/**
+ * @brief facade class around vkb::sg::Material, providing a vulkan.hpp-based interface
+ *
+ * See vkb::sb::Material for documentation
+ */
+class HPPMaterial : private vkb::sg::Material
+{
+  public:
+	std::unordered_map<std::string, vkb::scene_graph::components::HPPTexture *> const &get_textures() const
+	{
+		return reinterpret_cast<std::unordered_map<std::string, vkb::scene_graph::components::HPPTexture *> const &>(vkb::sg::Material::textures);
+	}
+};
+}        // namespace components
+}        // namespace scene_graph
+}        // namespace vkb

framework/scene_graph/components/hpp_mesh.h

@@ -0,0 +1,44 @@
+/* Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "hpp_sub_mesh.h"
+#include "mesh.h"
+
+namespace vkb
+{
+namespace scene_graph
+{
+namespace components
+{
+/**
+ * @brief facade class around vkb::sg::Mesh, providing a vulkan.hpp-based interface
+ *
+ * See vkb::sb::Mesh for documentation
+ */
+class HPPMesh : private vkb::sg::Mesh
+{
+  public:
+	std::vector<vkb::scene_graph::components::HPPSubMesh *> const &get_submeshes() const
+	{
+		return reinterpret_cast<std::vector<vkb::scene_graph::components::HPPSubMesh *> const &>(vkb::sg::Mesh::get_submeshes());
+	}
+};
+}        // namespace components
+}        // namespace scene_graph
+}        // namespace vkb

framework/scene_graph/components/hpp_sub_mesh.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
+/* Copyright (c) 2021-2024, NVIDIA CORPORATION. All rights reserved.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -18,6 +18,7 @@
 #pragma once
 
 #include <core/hpp_buffer.h>
+#include <scene_graph/components/hpp_material.h>
 #include <scene_graph/components/sub_mesh.h>
 
 namespace vkb
@@ -46,6 +47,11 @@ class HPPSubMesh : private vkb::sg::SubMesh
 		return static_cast<vk::IndexType>(vkb::sg::SubMesh::index_type);
 	}
 
+	vkb::scene_graph::components::HPPMaterial const *get_material() const
+	{
+		return reinterpret_cast<vkb::scene_graph::components::HPPMaterial const *>(vkb::sg::SubMesh::get_material());
+	}
+
 	vkb::core::HPPBuffer const &get_vertex_buffer(std::string const &name) const
 	{
 		return reinterpret_cast<vkb::core::HPPBuffer const &>(vkb::sg::SubMesh::vertex_buffers.at(name));

framework/scene_graph/components/hpp_texture.h

@@ -0,0 +1,49 @@
+/* Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "hpp_image.h"
+#include "texture.h"
+
+namespace vkb
+{
+namespace scene_graph
+{
+namespace components
+{
+/**
+ * @brief facade class around vkb::sg::Texture, providing a vulkan.hpp-based interface
+ *
+ * See vkb::sb::Texture for documentation
+ */
+class HPPTexture : private vkb::sg::Texture
+{
+  public:
+	vkb::scene_graph::components::HPPImage *get_image()
+	{
+		return reinterpret_cast<vkb::scene_graph::components::HPPImage *>(vkb::sg::Texture::get_image());
+	}
+
+	void set_image(vkb::scene_graph::components::HPPImage &image)
+	{
+		vkb::sg::Texture::set_image(reinterpret_cast<vkb::sg::Image &>(image));
+	}
+};
+}        // namespace components
+}        // namespace scene_graph
+}        // namespace vkb

framework/scene_graph/hpp_scene.h

@@ -0,0 +1,71 @@
+/* Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "components/hpp_mesh.h"
+#include "scene.h"
+#include "scene_graph/script.h"
+#include "scene_graph/scripts/animation.h"
+
+namespace vkb
+{
+namespace scene_graph
+{
+/**
+ * @brief facade class around vkb::sg::Scene, providing a vulkan.hpp-based interface
+ *
+ * See vkb::sb::Scene for documentation
+ */
+class HPPScene : private vkb::sg::Scene
+{
+  public:
+	template <class T>
+	std::vector<T *> get_components() const
+	{
+		if constexpr (std::is_same<T, vkb::sg::Script>::value)
+		{
+			return vkb::sg::Scene::get_components<T>();
+		}
+		else if constexpr (std::is_same<T, vkb::scene_graph::components::HPPMesh>::value)
+		{
+			std::vector<vkb::sg::Mesh *> meshes = vkb::sg::Scene::get_components<vkb::sg::Mesh>();
+			return *reinterpret_cast<std::vector<T *> *>(&meshes);
+		}
+		else
+		{
+			assert(false);        // path never passed -> Please add a type-check here!
+			return {};
+		}
+	}
+
+	template <class T>
+	bool has_component() const
+	{
+		if constexpr (std::is_same<T, vkb::sg::Animation>::value || std::is_same<T, vkb::sg::Script>::value)
+		{
+			return vkb::sg::Scene::has_component(typeid(T));
+		}
+		else
+		{
+			assert(false);        // path never passed -> Please add a type-check here!
+			return false;
+		}
+	}
+};
+}        // namespace scene_graph
+}        // namespace vkb