wip: context builder

Author: tomadamatkinson

components/vulkan/CMakeLists.txt

@@ -22,8 +22,8 @@ vkb__register_component(
   INCLUDE_DIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/include
   SRC
-    src/instance_builder.cpp
-    src/context_builder_funcs.cpp
+    # src/instance_builder.cpp
+    # src/context_builder_funcs.cpp
 )
 
 vkb__register_tests(

components/vulkan/include/components/vulkan/context/context_builder.hpp

@@ -80,29 +80,21 @@ class InstanceBuilder final
 		return *this;
 	}
 
-	inline Self &optional_extension(std::string_view layer_name, std::string_view extension_name, EnabledCallback callback = nullptr)
-	{
-		_optional_extensions.push_back(extension);
-		return *this;
-	}
+	/**
+	 * @brief A function used to indicate if a feature was enabled or disabled
+	 * 
+	 */
+	using Callback = std::function<void(bool)>;
 
-	inline Self &required_extension(std::string_view layer_name, std::string_view extension_name, EnabledCallback callback = nullptr)
-	{
-		_required_extensions.push_back(extension);
-		return *this;
-	}
+	Self &optional_extension(std::string_view extension_name, Callback callback = nullptr);
+	Self &optional_extension(std::string_view layer_name, std::string_view extension_name, Callback callback = nullptr);
 
-	inline Self &optional_layer(std::string_view layer, EnabledCallback callback = nullptr)
-	{
-		_optional_layers.push_back(layer);
-		return *this;
-	}
+	Self &required_extension(std::string_view extension_name, Callback callback = nullptr);
+	Self &required_extension(std::string_view layer_name, std::string_view extension_name, Callback callback = nullptr);
 
-	inline Self &required_layer(std::string_view layer, EnabledCallback callback = nullptr)
-	{
-		_required_layers.push_back({layer, callback});
-		return *this;
-	}
+	Self &optional_layer(std::string_view layer, Callback callback = nullptr);
+
+	Self &required_layer(std::string_view layer, Callback callback = nullptr);
 
 	template <typename Type>
 	using ExtensionFunc = std::function<void(Type &extension)>;
@@ -117,6 +109,14 @@ class InstanceBuilder final
   private:
 	VkInstance Build();
 
+	std::vector<std::string_view> _available_layers;
+
+	bool layer_available(std::string_view name);
+
+	std::unordered_map<std::string_view, std::vector<std::string_view>> _available_extension_layers;
+
+	bool extension_available(std::string_view layer, std::string_view name);
+
 	VkApplicationInfo             _application_info;
 	std::vector<std::string_view> _optional_extensions;
 	std::vector<std::string_view> _required_extensions;

components/vulkan/src/instance_builder.cpp

@@ -130,6 +130,102 @@ InstanceBuilder &InstanceBuilder::enable_validation_layers(const std::vector<std
 	return *this;
 }
 
+InstanceBuilder::InstanceBuilder()
+{
+	std::vector<std::string_view> emabled_layers;
+	uint32_t                      instance_layer_count;
+	VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
+	std::vector<VkLayerProperties> supported_validation_layers(instance_layer_count);
+	VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_validation_layers.data()));
+}
+
+InstanceBuilder &InstanceBuilder::optional_extension(std::string_view extension_name, Callback callback)
+{
+	if (extension_available("", extension_name))
+	{
+		_optional_extensions.push_back(extension_name);
+		callback(true);
+	}
+	else
+	{
+		callback(false);
+	}
+
+	return *this;
+}
+
+InstanceBuilder &InstanceBuilder::optional_extension(std::string_view layer_name, std::string_view extension_name, Callback callback)
+{
+	if (extension_available(layer_name, extension_name))
+	{
+		_optional_extensions.push_back(extension_name);
+		callback(true);
+	}
+	else
+	{
+		callback(false);
+	}
+
+	return *this;
+}
+
+InstanceBuilder &InstanceBuilder::required_extension(std::string_view extension_name)
+{
+	if (extension_available("", extension_name))
+	{
+		_required_extensions.push_back(extension_name);
+	}
+	else
+	{
+		throw "required extension is not available";        // TODO: replace this with better error handling
+	}
+
+	return *this;
+}
+
+InstanceBuilder &InstanceBuilder::required_extension(std::string_view layer_name, std::string_view extension_name)
+{
+	if (extension_available(layer_name, extension_name))
+	{
+		_required_extensions.push_back(extension_name);
+	}
+	else
+	{
+		throw "required extension is not available";        // TODO: replace this with better error handling
+	}
+
+	return *this;
+}
+
+InstanceBuilder &InstanceBuilder::optional_layer(std::string_view layer, Callback callback)
+{
+	if (layer_available(layer))
+	{
+		_optional_layers.push_back(layer);
+		callback(true);
+	}
+	else
+	{
+		callback(false);
+	}
+
+	return *this;
+}
+
+InstanceBuilder &InstanceBuilder::required_layer(std::string_view layer)
+{
+	if (layer_available(layer))
+	{
+		_required_layers.push_back(layer);
+	}
+	else
+	{
+		throw "required layer is not available";        // TODO: replace this with better error handling
+	}
+
+	return *this;
+}
+
 std::vector<std::string_view> InstanceBuilder::collect_enabled_extensions(VkInstanceCreateInfo &info) const
 {
 	std::vector<std::string_view> enabled_extensions;
@@ -205,23 +301,6 @@ std::vector<std::string_view> InstanceBuilder::collect_enabled_extensions(VkInst
 	return enabled_extensions;
 }
 
-std::vector<std::string_view> InstanceBuilder::collect_enabled_layers(VkInstanceCreateInfo &info) const
-{
-	std::vector<std::string_view> emabled_layers;
-
-	uint32_t instance_layer_count;
-	VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
-
-	std::vector<VkLayerProperties> supported_validation_layers(instance_layer_count);
-	VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_validation_layers.data()));
-
-	std::vector<const char *> requested_validation_layers(required_validation_layers);
-
-	// TODO: process layers
-
-	return enabled_layers;
-}
-
 InstanceBuilder::Instance InstanceBuilder::Build()
 {
 	VkInstanceCreateInfo instance_info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};