[#7] add new context functionalities

The validation layers are only enabled, if in debug mode in the IDE.
If enabled, it will be checked, if validation layers are supported.

Extensions for both the instance and the physical device can be added via the Context::create() function.
Per default, the instanceExtensions and deviceExtensions are empty.
Thus, the user is not forced to add any extension.

Queues are now supported!
The user can determine the amount of queues (default: 1, but we can change that...) and their purpose e.g. COMPUTE or TRANSFER etc.
If their amount and purpose is specified it is checked, if the picked physical device has enough of them.
The queues are chosen in a way that the maximal amount of available queues of specified purpose are picked,
Example 1: If we choose 20 queues with purpose COMPUTE and we have 16 of them available, we pick 16 of them.
Example 2: If we choose 30 queues with no specified purpose, we choose as many queues as we have available.

If the computer has more than one physical device available (e.g. an integrated and an dedicated GPU or several dedicated GPUs), then it will be checked, which of all available devices is the optimal one.
The choice is based on a scoring system.
The choice criteria are: the abilities of the available queues, the VRAM and the GPU type (discrete vs. integrated vs. other)

projects/first_triangle/src/main.cpp

-
 #include <iostream>
 #include <vkcv/Context.hpp>
 
 int main(int argc, const char** argv) {
 	vkcv::Context context = vkcv::Context::create(
-			"First Triangle",
-			VK_MAKE_VERSION(0, 0, 1)
+		"First Triangle",
+		VK_MAKE_VERSION(0, 0, 1),
+		20,
+		{vk::QueueFlagBits::eGraphics, vk::QueueFlagBits::eTransfer}
 	);
 
 	const vk::Instance& instance = context.getInstance();

src/vkcv/Context.cpp

-
 #include "Context.hpp"
 
+
+std::vector<const char*> validationLayers = {
+	"VK_LAYER_KHRONOS_validation"
+};
+
+
 namespace vkcv {
 
 	Context::Context(vk::Instance instance, vk::PhysicalDevice physicalDevice, vk::Device device)
@@ -11,8 +16,35 @@ namespace vkcv {
 		m_device.destroy();
 		m_instance.destroy();
 	}
-	
-	Context Context::create(const char* applicationName, uint32_t applicationVersion) {
+
+	Context Context::create(const char* applicationName, uint32_t applicationVersion, uint32_t queueCount, std::vector<vk::QueueFlagBits> queueFlags, std::vector<const char*> instanceExtensions, std::vector<const char*> deviceExtensions) {
+		glfwInit();
+		
+		// check for layer support
+		uint32_t layerCount = 0;
+		vk::enumerateInstanceLayerProperties(&layerCount, nullptr);
+		std::vector<vk::LayerProperties> layerProperties(layerCount);
+		vk::enumerateInstanceLayerProperties(&layerCount, layerProperties.data());
+		std::vector<const char*> supportedLayers;
+		for (auto& elem : layerProperties)
+			supportedLayers.push_back(elem.layerName);
+
+		// if in debug mode, check if validation layers are supported. Enable them if supported
+		if (enableValidationLayers && !Context::checkSupport(supportedLayers, validationLayers))
+			throw std::runtime_error("Validation layers requested but not available!");
+		
+		// check for extension support
+		std::vector<vk::ExtensionProperties> instanceExtensionProperties = vk::enumerateInstanceExtensionProperties();
+		std::vector<const char*> supportedExtensions;
+		for (auto& elem : instanceExtensionProperties)
+			supportedExtensions.push_back(elem.extensionName);
+		if (!checkSupport(supportedExtensions, instanceExtensions))
+			throw std::runtime_error("The requested instance extensions are not supported!");
+
+		// for GLFW: get all required extensions
+		std::vector<const char*> requiredExtensions = Context::getRequiredExtensions();
+		instanceExtensions.insert(instanceExtensions.end(), requiredExtensions.begin(), requiredExtensions.end());
+
 		const vk::ApplicationInfo applicationInfo (
 				applicationName,
 				applicationVersion,
@@ -20,35 +52,45 @@ namespace vkcv {
 				VK_MAKE_VERSION(0, 0, 1),
 				VK_HEADER_VERSION_COMPLETE
 		);
-		
-		// TODO: enable validation layers in debug build and add required extensions
-		const vk::InstanceCreateInfo instanceCreateInfo (
-				vk::InstanceCreateFlags(),
-				&applicationInfo,
-				0,
-				nullptr,
-				0,
-				nullptr
+
+		const vk::InstanceCreateInfo instanceCreateInfo(
+			vk::InstanceCreateFlags(),
+			&applicationInfo,
+			(enableValidationLayers) ? static_cast<uint32_t>(validationLayers.size()) : 0,
+			(enableValidationLayers) ? validationLayers.data() : nullptr,
+			static_cast<uint32_t>(instanceExtensions.size()),
+			instanceExtensions.data()
 		);
-		
+
 		vk::Instance instance = vk::createInstance(instanceCreateInfo);
-		
-		// TODO: search for the best physical device (discrete GPU)
-		vk::PhysicalDevice physicalDevice = instance.enumeratePhysicalDevices()[0];
-		
-		// TODO: create required queues, add validation layers and required extensions
+
+		std::vector<vk::PhysicalDevice> physicalDevices = instance.enumeratePhysicalDevices();
+		vk::PhysicalDevice physicalDevice = pickPhysicalDevice(instance);
+
+		// check for physical device extension support
+		std::vector<vk::ExtensionProperties> deviceExtensionProperties = physicalDevice.enumerateDeviceExtensionProperties();
+		supportedExtensions.clear();
+		for (auto& elem : deviceExtensionProperties)
+			supportedExtensions.push_back(elem.extensionName);
+		if (!checkSupport(supportedExtensions, deviceExtensions))
+			throw std::runtime_error("The requested device extensions are not supported by the physical device!");
+
+		// create required queues
+		std::vector<vk::DeviceQueueCreateInfo> qCreateInfos = getQueueCreateInfos(physicalDevice, queueCount, queueFlags);
+
 		const vk::DeviceCreateInfo deviceCreateInfo (
 				vk::DeviceCreateFlags(),
-				0,
-				nullptr,
-				0,
-				nullptr,
-				0,
-				nullptr,
-				nullptr
+				qCreateInfos.size(),
+				qCreateInfos.data(),
+				(enableValidationLayers) ? static_cast<uint32_t>(validationLayers.size()) : 0,
+				(enableValidationLayers) ? validationLayers.data() : nullptr,
+				deviceExtensions.size(),
+				deviceExtensions.data(),
+				nullptr		// Should our device use some features??? If yes: TODO
 		);
 		
 		vk::Device device = physicalDevice.createDevice(deviceCreateInfo);
+		// TODO: implement device.getQueue() to access the queues, if needed
 		
 		return Context(instance, physicalDevice, device);
 	}
@@ -64,4 +106,171 @@ namespace vkcv {
 	const vk::Device& Context::getDevice() const {
 		return m_device;
 	}
+
+	/// <summary>
+	/// All existing physical devices will be evaluated by 
+	/// </summary>
+	/// <param name="instance">The instance.</param>
+	/// <returns>The optimal physical device.</returns>
+	/// <seealso cref="Context.deviceScore">
+	vk::PhysicalDevice Context::pickPhysicalDevice(vk::Instance& instance) {
+		vk::PhysicalDevice phyDevice;
+		uint32_t deviceCount = 0;
+		instance.enumeratePhysicalDevices(&deviceCount, nullptr);
+		if (deviceCount == 0) {
+			throw std::runtime_error("failed to find GPUs with Vulkan support!");
+		}
+		std::vector<vk::PhysicalDevice> devices(deviceCount);
+		instance.enumeratePhysicalDevices(&deviceCount, devices.data());
+		int max_score = -1;
+		for (const auto& device : devices) {
+			int score = deviceScore(device);
+			if (score > max_score) {
+				max_score = score;
+				phyDevice = device;
+			}
+		}
+
+		if (&phyDevice == nullptr) {
+			throw std::runtime_error("failed to find a suitable GPU!");
+		}
+
+		return phyDevice;
+	}
+
+	/// <summary>
+	/// The physical device is evaluated by three categories: discrete GPU vs. integrated GPU, amount of queues and
+	/// its abilities, and VRAM.
+	/// </summary>
+	/// <param name="physicalDevice"> The physical device. </param>
+	/// <returns></returns>
+	int Context::deviceScore(const vk::PhysicalDevice& physicalDevice) {
+		int score = 0;
+		vk::PhysicalDeviceProperties properties = physicalDevice.getProperties();
+		std::vector<vk::QueueFamilyProperties> qFamilyProperties = physicalDevice.getQueueFamilyProperties();
+
+		// for every queue family compute queue flag bits and the amount of queues
+		for (const auto& qFamily : qFamilyProperties) {
+			uint32_t qCount = qFamily.queueCount;
+			uint32_t bitCount = (static_cast<uint32_t>(qFamily.queueFlags & vk::QueueFlagBits::eCompute) != 0)
+				+ (static_cast<uint32_t>(qFamily.queueFlags & vk::QueueFlagBits::eGraphics) != 0)
+				+ (static_cast<uint32_t>(qFamily.queueFlags & vk::QueueFlagBits::eTransfer) != 0)
+				+ (static_cast<uint32_t>(qFamily.queueFlags & vk::QueueFlagBits::eSparseBinding) != 0);
+			score += qCount * bitCount;
+		}
+
+		// compute the VRAM of the physical device
+		vk::PhysicalDeviceMemoryProperties memoryProperties = physicalDevice.getMemoryProperties();
+		int vram = static_cast<int>(memoryProperties.memoryHeaps[0].size / 1E9);
+		score *= vram;
+
+		if (properties.deviceType == vk::PhysicalDeviceType::eDiscreteGpu) {
+			// nice!
+			score *= 2;
+		}
+		else if (properties.deviceType == vk::PhysicalDeviceType::eIntegratedGpu) {
+			// not perfect but ok
+		}
+		else {
+			// not so nice
+			score *= -1;
+		}
+
+		return score;
+	}
+
+	/// <summary>
+	/// Creates a candidate list of queues that all meet the desired flags and then creates the maximum possible number
+	/// of queues. If the number of desired queues is not sufficient, the remaining queues are created from the next
+	/// candidate from the list.
+	/// </summary>
+	/// <param name="physicalDevice">The physical device</param>
+	/// <param name="queueCount">The amount of queues to be created</param>
+	/// <param name="queueFlags">The abilities which have to be supported by any created queue</param>
+	/// <returns></returns>
+	std::vector<vk::DeviceQueueCreateInfo> Context::getQueueCreateInfos(vk::PhysicalDevice& physicalDevice, uint32_t queueCount, std::vector<vk::QueueFlagBits>& queueFlags) {
+		std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
+		std::vector<vk::QueueFamilyProperties> qFamilyProperties = physicalDevice.getQueueFamilyProperties();
+		std::vector<vk::QueueFamilyProperties> qFamilyCandidates;
+
+		// search for queue families which support the desired queue flag bits
+		for (auto& qFamily : qFamilyProperties) {
+			bool supported = true;
+			for (auto qFlag : queueFlags) {
+				supported = supported && (static_cast<uint32_t>(qFlag & qFamily.queueFlags) != 0);
+			}
+			if (supported) {
+				qFamilyCandidates.push_back(qFamily);
+			}
+		}
+
+		uint32_t create = queueCount;
+		for (int i = 0; i < qFamilyCandidates.size() && create > 0; i++) {
+			const int availableQueues = qFamilyCandidates[i].queueCount;
+			if (create >= availableQueues) {
+				float* qPriorities = new float[availableQueues];
+				std::fill_n(qPriorities, availableQueues, 1.f);		// all queues have the same priorities
+				vk::DeviceQueueCreateInfo qCreateInfo(
+					vk::DeviceQueueCreateFlags(),
+					i,
+					qFamilyCandidates[i].queueCount,
+					qPriorities
+				);
+				queueCreateInfos.push_back(qCreateInfo);
+				create -= qFamilyCandidates[i].queueCount;
+			}
+			else {
+				float* qPriorities = new float[create];
+				std::fill_n(qPriorities, create, 1.f);				// all queues have the same priorities
+				vk::DeviceQueueCreateInfo qCreateInfo(
+					vk::DeviceQueueCreateFlags(),
+					i,
+					create,
+					qPriorities
+				);
+				queueCreateInfos.push_back(qCreateInfo);
+				create -= create;
+			}
+		}
+
+		return queueCreateInfos;
+	}
+
+	/// <summary>
+	/// With the help of the reference <paramref name="supported"> all elements in <paramref name="check"/> checked,
+	/// if they are supported by the physical device.
+	/// </summary>
+	/// <param name="supported">The reference that can be used to check <paramref name="check"/></param>
+	/// <param name="check">The elements to be checked</param>
+	/// <returns>True, if all elements in <param name="check"> are supported</returns>
+	bool Context::checkSupport(std::vector<const char*>& supported, std::vector<const char*>& check) {
+		for (auto checkElem : check) {
+			bool found = false;
+			for (auto supportedElem : supported) {
+				if (strcmp(supportedElem, checkElem) == 0) {
+					found = true;
+					break;
+				}
+			}
+			if (!found)
+				return false;
+		}
+		return true;
+	}
+
+	/// <summary>
+	/// Gets all extensions required, i.e. GLFW and advanced debug extensions.
+	/// </summary>
+	/// <returns>The required extensions</returns>
+	std::vector<const char*> Context::getRequiredExtensions() {
+		uint32_t glfwExtensionCount = 0;
+		const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+		std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
+
+		if (enableValidationLayers) {
+			extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+		}
+
+		return extensions;
+	}
 }

src/vkcv/Context.hpp

 #pragma once
-
 #include <vulkan/vulkan.hpp>
+#include <GLFW/glfw3.h>
+#include <iostream>
+
+#ifdef NDEBUG
+const bool enableValidationLayers = false;
+#else
+const bool enableValidationLayers = true;
+#endif
 
 namespace vkcv {
 
@@ -9,9 +16,10 @@ namespace vkcv {
 		vk::Instance m_instance;
 		vk::PhysicalDevice m_physicalDevice;
 		vk::Device m_device;
-		
+
 		Context(vk::Instance instance, vk::PhysicalDevice physicalDevice, vk::Device device);
 
+
 	public:
 		Context(const Context &other) = delete;
 		Context(Context &&other) = default;
@@ -29,9 +37,13 @@ namespace vkcv {
 
 		Context& operator=(const Context &other) = delete;
 		Context& operator=(Context &&other) = default;
-		
-		static Context create(const char* applicationName, uint32_t applicationVersion);
-		
+
+		static Context create(const char* applicationName, uint32_t applicationVersion, uint32_t queueCount = 1, const std::vector<vk::QueueFlagBits> queueFlags = {}, std::vector<const char*> instanceExtensions = {}, std::vector<const char*> deviceExtensions = {});
+		static bool checkSupport(std::vector<const char*> &supported, std::vector<const char*> &check);
+		static std::vector<const char*> getRequiredExtensions();
+		static vk::PhysicalDevice Context::pickPhysicalDevice(vk::Instance& instance);
+		static int deviceScore(const vk::PhysicalDevice &physicalDevice);
+		static std::vector<vk::DeviceQueueCreateInfo> getQueueCreateInfos(vk::PhysicalDevice& physicalDevice, uint32_t queueCount, std::vector<vk::QueueFlagBits> &queueFlags);
 	};
 
 }