gistfile1.txt

#define GLFW_INCLUDE_VULKAN
#include "GLFW/glfw3.h"
#include "kissmath.hpp"
#include "assert.h"
#include <vector>

const bool enable_validation_layers = true;
const std::vector<char const*> validation_layers = {
	"VK_LAYER_KHRONOS_validation"
};

const int2 size = int2(1280, 720);

VkInstance instance;
VkDebugUtilsMessengerEXT debug_messenger;

VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback (VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {
	printf("Validation Layer: %s\n", pCallbackData->pMessage);

	return VK_FALSE;
}

void vk_set_debug_utils_messenger_create_info_ext (VkDebugUtilsMessengerCreateInfoEXT* create_info) {
	create_info->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
	create_info->messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
	create_info->messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
	create_info->pfnUserCallback = vk_debug_callback;
	create_info->pUserData = nullptr;
}

VkResult vk_create_debug_utils_messenger_ext () {
	VkDebugUtilsMessengerCreateInfoEXT create_info = {};
	vk_set_debug_utils_messenger_create_info_ext(&create_info);

	auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
	if (!func) return VK_ERROR_EXTENSION_NOT_PRESENT;

	return func(instance, &create_info, nullptr, &debug_messenger);
}
void vk_destroy_debug_utils_messenger_ext () {
	auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
	if (!func) return;
	
	func(instance, debug_messenger, nullptr);
}

void vk_create_instance () {
	// Check extensions
	uint32_t avail_extension_count = 0;
	vkEnumerateInstanceExtensionProperties(nullptr, &avail_extension_count, nullptr);

	std::vector<VkExtensionProperties> avail_extensions (avail_extension_count);
	vkEnumerateInstanceExtensionProperties(nullptr, &avail_extension_count, avail_extensions.data());

	uint32_t request_extension_count = 0;
	auto request_extension_names = glfwGetRequiredInstanceExtensions(&request_extension_count);
	std::vector<char const*> request_extensions (request_extension_names, request_extension_names + request_extension_count);

	// Check validation layers
	std::vector<char const*> request_layers;
	if (enable_validation_layers) {

		request_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);

		uint32_t layers_count = 0;
		vkEnumerateInstanceLayerProperties(&layers_count, nullptr);

		std::vector<VkLayerProperties> avail_layers(layers_count);
		vkEnumerateInstanceLayerProperties(&layers_count, avail_layers.data());

		for (auto req : validation_layers) {
			for (auto avail : avail_layers) {
				if (strcmp(req, avail.layerName) == 0) {
					request_layers.push_back(req);
					break;
				}
			}
		}
	}

	// Create instance
	VkApplicationInfo app_info = {};
	app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	app_info.pApplicationName = "Hello Triangle";
	app_info.applicationVersion = VK_MAKE_VERSION(1,0,0);
	app_info.pEngineName = "No Engine";
	app_info.engineVersion = VK_MAKE_VERSION(1,0,0);
	app_info.apiVersion = VK_API_VERSION_1_0;

	VkInstanceCreateInfo create_info = {};
	create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	create_info.pApplicationInfo = &app_info;

	create_info.enabledExtensionCount	= (uint32_t)request_extensions.size();
	create_info.ppEnabledExtensionNames = request_extensions.size() > 0 ? request_extensions.data() : nullptr;

	create_info.enabledLayerCount	= (uint32_t)request_layers.size();
	create_info.ppEnabledLayerNames = request_layers.size() > 0 ? request_layers.data() : nullptr;

	VkDebugUtilsMessengerCreateInfoEXT dbg_create_info = {};
	if (enable_validation_layers) {
		vk_set_debug_utils_messenger_create_info_ext(&dbg_create_info);
		create_info.pNext = &dbg_create_info;
	}

	VkResult res = vkCreateInstance(&create_info, nullptr, &instance);
	assert(res == VK_SUCCESS);
}

void vk_init () {
	// Create instance 
	vk_create_instance();

	// Debug callback
	if (enable_validation_layers)
		vk_create_debug_utils_messenger_ext();



}

void vk_deinit () {
	//if (enable_validation_layers)
		//vk_destroy_debug_utils_messenger_ext();

	vkDestroyInstance(instance, nullptr);
}

int main () {

	glfwInit();

	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);

	GLFWwindow* window = glfwCreateWindow(size.x, size.y, "Vulkan window", nullptr, nullptr);

	vk_init();

	while(!glfwWindowShouldClose(window)) {
		glfwPollEvents();
	}

	vk_deinit();

	glfwDestroyWindow(window);

	glfwTerminate();

	return 0;
}