Vulkan Basic Startup C++

main.cpp

//Mit dem Angriff Steiners wird alles in Ordnung sein!

#include <vulkan\vulkan.h>
#include <iostream>
#include <string>
#include <vector>

#pragma comment(lib, "vulkan-1.lib")

std::string getVersionString(uint32_t versionBitmask) {
	char versionString[128];

	uint32_t uMajorAPIVersion = versionBitmask >> 22;
	uint32_t uMinorAPIVersion = ((versionBitmask << 10) >> 10) >> 12;
	uint32_t uPatchAPIVersion = (versionBitmask << 20) >> 20;

	int majorAPIVersion = uMajorAPIVersion;
	int minorAPIVersion = uMinorAPIVersion;
	int patchAPIVersion = uPatchAPIVersion;

	sprintf_s(versionString, 128, "%d.%d.%d", majorAPIVersion, minorAPIVersion, patchAPIVersion);

	return versionString;
}

int main() {
	uint32_t instanceExtensionsCount = -1;
	std::vector<VkExtensionProperties> instanceExtensions;

	vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtensionsCount, nullptr);

	instanceExtensions.resize(instanceExtensionsCount);

	vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtensionsCount, instanceExtensions.data());

	std::cout << "Instance Extensions:\n";

	for (int i = 0; i < instanceExtensionsCount; i++) {
		std::cout << "\t" << instanceExtensions[i].extensionName << "(" << std::to_string(instanceExtensions[i].specVersion) << ")\n";
	}

	VkInstanceCreateInfo vkInstanceCreateInfo = {};
	VkApplicationInfo vkAppInfo = { };
	VkInstance vkInstance;

	vkAppInfo.apiVersion = VK_MAKE_VERSION(1, 0, 0);
	vkAppInfo.applicationVersion = 1;
	vkAppInfo.pApplicationName = "Vulkan Test";


	vkInstanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	vkInstanceCreateInfo.pApplicationInfo = &vkAppInfo;

	if (vkCreateInstance(&vkInstanceCreateInfo, nullptr, &vkInstance) == VK_SUCCESS) {
		uint32_t vkNumberOfSupportedDevices = 1;
		VkPhysicalDevice vkPhysicalDevices[1];

		if (vkEnumeratePhysicalDevices(vkInstance, &vkNumberOfSupportedDevices, vkPhysicalDevices) == VK_SUCCESS) {

			VkPhysicalDeviceProperties vkDeviceProperties = {};

			vkGetPhysicalDeviceProperties(vkPhysicalDevices[0], &vkDeviceProperties);

			std::cout << "Device Name:\t" << vkDeviceProperties.deviceName << std::endl;
			switch (vkDeviceProperties.deviceType) {
			case VK_PHYSICAL_DEVICE_TYPE_CPU:
				std::cout << "Device Type:\tCPU" << std::endl;
				break;
			case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
				std::cout << "Device Type:\tDiscrete GPU" << std::endl;
				break;
			case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
				std::cout << "Device Type:\tIntegrated GPU" << std::endl;
				break;
			case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
				std::cout << "Device Type:\tVirtual GPU" << std::endl;
				break;
			case VK_PHYSICAL_DEVICE_TYPE_OTHER:
				std::cout << "Device Type:\tOther" << std::endl;
				break;
			}



			std::cout << "Highest Supported Vulkan Version:\t" << getVersionString(vkDeviceProperties.apiVersion) << std::endl;

			VkPhysicalDeviceFeatures vkSupportedDeviceFeatures = {};
			VkPhysicalDeviceFeatures vkDesiredDeviceFeatures = {};

			vkGetPhysicalDeviceFeatures(vkPhysicalDevices[0], &vkSupportedDeviceFeatures);

			std::cout << "Supports Tesselation Shader Feature:\t" << ((vkSupportedDeviceFeatures.tessellationShader) ? ("Yes") : ("No")) << std::endl;

			VkPhysicalDeviceMemoryProperties vkDeviceMemoryProperties = {};

			vkGetPhysicalDeviceMemoryProperties(vkPhysicalDevices[0], &vkDeviceMemoryProperties);

			uint64_t vkLocalMemorySize = 0;

			for (int i = 0; i < vkDeviceMemoryProperties.memoryTypeCount; i++) {
				int heapIndex = vkDeviceMemoryProperties.memoryTypes[i].heapIndex;

				//if ((((deviceMemoryProperties.memoryTypes[i].propertyFlags << (31 - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) >> (31 - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) >> VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
				vkLocalMemorySize += vkDeviceMemoryProperties.memoryHeaps[heapIndex].size;
			}

			std::cout << "Total Heaps Size:\t" << std::to_string((float)vkLocalMemorySize / (1024 * 1024 * 1024)) << "GB" << std::endl;


			uint32_t vkNumQueueFamilies = 0;

			vkGetPhysicalDeviceQueueFamilyProperties(vkPhysicalDevices[0], &vkNumQueueFamilies, nullptr);

			std::cout << "Number of Queue Families:\t" << std::to_string(vkNumQueueFamilies) << std::endl;

			std::vector<VkQueueFamilyProperties> vkQueueFamilyProperties;

			vkQueueFamilyProperties.resize(vkNumQueueFamilies);

			vkGetPhysicalDeviceQueueFamilyProperties(vkPhysicalDevices[0], &vkNumQueueFamilies, vkQueueFamilyProperties.data());

			uint32_t queueCount = 0;

			uint32_t graphicQueueFamilyIndex = -1;
			uint32_t graphicQueueFamilyNumQueue = 0;

			for (int i = 0; i < vkNumQueueFamilies; i++) {
				if (vkQueueFamilyProperties[i].queueFlags % 2 == 1) {
					graphicQueueFamilyIndex = i;
					graphicQueueFamilyNumQueue = vkQueueFamilyProperties[i].queueCount;
				}

				queueCount += vkQueueFamilyProperties[i].queueCount;
			}

			if (graphicQueueFamilyIndex == -1 || graphicQueueFamilyNumQueue == 0) {
				std::cerr << "Cannot find graphical queue family with queues available." << std::endl;

				exit(EXIT_FAILURE);
			}

			std::cout << "Total Device Queue Count:\t" << std::to_string(queueCount) << std::endl;

			VkDeviceCreateInfo logicalDeviceCreateInfo;
			VkDeviceQueueCreateInfo deviceQueueCreateInfo;

			deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
			deviceQueueCreateInfo.flags = 0;
			deviceQueueCreateInfo.pNext = nullptr;
			deviceQueueCreateInfo.queueFamilyIndex = graphicQueueFamilyIndex;
			deviceQueueCreateInfo.queueCount = graphicQueueFamilyNumQueue;
			deviceQueueCreateInfo.pQueuePriorities = new const float[1]{ 1.0f };


			vkDesiredDeviceFeatures.tessellationShader = VK_TRUE;
			vkDesiredDeviceFeatures.geometryShader = VK_TRUE;
			vkDesiredDeviceFeatures.multiDrawIndirect = vkSupportedDeviceFeatures.multiDrawIndirect;


			logicalDeviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
			logicalDeviceCreateInfo.flags = 0;
			logicalDeviceCreateInfo.pNext = nullptr;
			logicalDeviceCreateInfo.queueCreateInfoCount = 1;
			logicalDeviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
			logicalDeviceCreateInfo.enabledExtensionCount = 0;
			logicalDeviceCreateInfo.enabledLayerCount = 0;
			logicalDeviceCreateInfo.ppEnabledExtensionNames = nullptr;
			logicalDeviceCreateInfo.ppEnabledLayerNames = nullptr;
			logicalDeviceCreateInfo.pEnabledFeatures = &vkDesiredDeviceFeatures;

			VkDevice logicalDevice[1];


			if (vkCreateDevice(vkPhysicalDevices[0], &logicalDeviceCreateInfo, nullptr, logicalDevice) == VK_SUCCESS) {

				uint32_t layerPropertiesCount = -1;

				vkEnumerateDeviceLayerProperties(vkPhysicalDevices[0], &layerPropertiesCount, nullptr);

				std::cout << "Number of Device Layers available to physical device:\t" << std::to_string(layerPropertiesCount) << std::endl;

				std::vector<VkLayerProperties> vkLayerProperties;

				vkLayerProperties.resize(layerPropertiesCount);

				vkEnumerateDeviceLayerProperties(vkPhysicalDevices[0], &layerPropertiesCount, vkLayerProperties.data());

				std::cout << "Device Layers:\n";

				for (int i = 0; i < layerPropertiesCount; i++) {
					std::cout << "\tLayer #" << std::to_string(i) << std::endl;
					std::cout << "\t\tName:\t" << vkLayerProperties[i].layerName << std::endl;
					std::cout << "\t\tSpecification Version:\t" << getVersionString(vkLayerProperties[i].specVersion) << std::endl;
					std::cout << "\t\tDescription:\t" << vkLayerProperties[i].description << std::endl;
				}

				vkEnumerateInstanceLayerProperties(&layerPropertiesCount, nullptr);

				std::cout << "Number of Instance Layers available to physical device:\t" << std::to_string(layerPropertiesCount) << std::endl;

				vkLayerProperties.resize(layerPropertiesCount);

				vkEnumerateInstanceLayerProperties(&layerPropertiesCount, vkLayerProperties.data());

				std::cout << "Instance Layers:\n";

				for (int i = 0; i < layerPropertiesCount; i++) {
					std::cout << "\tLayer #" << std::to_string(i) << std::endl;
					std::cout << "\t\tName:\t" << vkLayerProperties[i].layerName << std::endl;
					std::cout << "\t\tSpecification Version:\t" << getVersionString(vkLayerProperties[i].specVersion) << std::endl;
					std::cout << "\t\tDescription:\t" << vkLayerProperties[i].description << std::endl;
				}


				uint32_t deviceExtensionsCount = 0;
				std::vector<VkExtensionProperties> deviceExtensions;

				vkEnumerateDeviceExtensionProperties(vkPhysicalDevices[0], nullptr, &deviceExtensionsCount, nullptr);

				deviceExtensions.resize(deviceExtensionsCount);

				vkEnumerateDeviceExtensionProperties(vkPhysicalDevices[0], nullptr, &deviceExtensionsCount, deviceExtensions.data());

				std::cout << "Device Extensions:\n";

				for (int i = 0; i < deviceExtensionsCount; i++) {
					std::cout << "\t" << deviceExtensions[i].extensionName << "(" << std::to_string(deviceExtensions[0].specVersion) << ")\n";
				}


			}
			else {
				std::cerr << "Logical Device creation failed." << std::endl;

				exit(EXIT_FAILURE);
			}


			getchar();
		}
		else {
			std::cerr << "Physical device enumeration failed.\n";

			exit(EXIT_FAILURE);
		}
	}
	else {
		std::cerr << "Instance creation failed.\n";

		exit(EXIT_FAILURE);
	}
}